# Music Genres Database API Documentation The **Music Genres Database API** provides comprehensive access to a meticulously curated database of 630+ music genres from around the world. From mainstream genres like rock and hip-hop to niche subgenres like dark ambient and folktronica, this API serves as the definitive resource for music discovery, streaming applications, recommendation engines, and music classification systems. ## 🌟 Key Features - **630+ Music Genres**: Comprehensive collection spanning all musical styles - **Detailed Information**: Genre names, representative artists, and classification data - **Multiple Search Methods**: Search by genre name, ID, or pattern matching - **Pagination Support**: Efficient data retrieval with customizable limits - **High Performance**: Optimized for speed with sub-100ms response times - **Production Ready**: Built for high-traffic applications with robust error handling ## 🔗 Base URL ``` https://music-genres-database.p.rapidapi.com ``` ## 🔑 Authentication This API uses RapidAPI's authentication system. You'll need: 1. A RapidAPI account (free to create) 2. Subscribe to the Music Genres Database API 3. Your unique API key from RapidAPI dashboard ### Required Headers ```http X-RapidAPI-Key: YOUR_RAPIDAPI_KEY_HERE X-RapidAPI-Host: music-genres-database.p.rapidapi.com ``` ## 📚 Endpoints ### 1. Get Music Genres **Endpoint:** `GET /` Retrieve music genres with various filtering and pagination options. #### Parameters | Parameter | Type | Required | Default | Description | |-----------|------|----------|---------|-------------| | `search` | string | No | - | Search genres by name (partial match) | | `genre` | string | No | - | Get specific genre by exact ID match | | `limit` | integer | No | 10 | Number of results to return (1-100) | | `offset` | integer | No | 0 | Number of results to skip | #### Example Requests **Get rock subgenres:** ``` GET /?search=rock&limit=5 ``` **Get specific genre:** ``` GET /?genre=rock_1 ``` **Get all genres with pagination:** ``` GET /?limit=20&offset=0 ``` #### Example Response ```json { "success": true, "count": 5, "data": [ { "id": "rock_1", "genre": "Alternative Rock", "representative_artists": "Nirvana, Pearl Jam, Radiohead" }, { "id": "rock_12", "genre": "Arena Rock", "representative_artists": "Queen, Journey, Boston" }, { "id": "rock_15", "genre": "Acid Rock", "representative_artists": "Jefferson Airplane, The Doors, Jimi Hendrix" }, { "id": "rock_23", "genre": "Art Rock", "representative_artists": "King Crimson, Genesis, Yes" }, { "id": "rock_45", "genre": "Classic Rock", "representative_artists": "Led Zeppelin, The Beatles, The Rolling Stones" } ], "pagination": { "limit": 5, "offset": 0, "total": 47 } } ``` ### 2. API Information **Endpoint:** `GET /info` Get detailed information about the API, including available parameters and usage statistics. #### Example Request ``` GET /info ``` #### Example Response ```json { "success": true, "api": { "name": "Music Genres Database", "version": "1.0", "description": "Comprehensive database of 630+ music genres with detailed information and representative artists", "total_genres": 630, "categories": [ "Rock", "Pop", "Hip-Hop", "Electronic", "Jazz", "Classical", "Folk", "Country", "R&B", "Reggae", "Metal", "Punk", "Blues" ], "endpoints": { "/": { "method": "GET", "description": "Get music genres with filtering and pagination", "parameters": { "search": "string - Search genres by name", "genre": "string - Get specific genre by ID", "limit": "integer - Results limit (1-100)", "offset": "integer - Results offset" } }, "/info": { "method": "GET", "description": "Get API information and documentation" } } } } ``` ## 🎯 Common Use Cases ### Music Streaming Applications Perfect for building genre-based playlists and music discovery features: ```javascript // Get electronic music subgenres for playlist creation const response = await fetch('/?search=electronic&limit=10', { headers: { 'X-RapidAPI-Key': 'YOUR_API_KEY', 'X-RapidAPI-Host': 'music-genres-database.p.rapidapi.com' } }); ``` ### Music Recommendation Engines Use for categorizing and recommending music based on genre preferences: ```javascript // Get specific genre details for recommendation algorithms const genreDetails = await fetch('/?genre=jazz_1', { headers: { 'X-RapidAPI-Key': 'YOUR_API_KEY', 'X-RapidAPI-Host': 'music-genres-database.p.rapidapi.com' } }); ``` ### Music Education Platforms Comprehensive genre information for educational content: ```javascript // Get all classical music subgenres for educational content const classicalGenres = await fetch('/?search=classical&limit=50', { headers: { 'X-RapidAPI-Key': 'YOUR_API_KEY', 'X-RapidAPI-Host': 'music-genres-database.p.rapidapi.com' } }); ``` ## 💻 Code Examples ### JavaScript (Node.js) ```javascript const axios = require('axios'); const options = { method: 'GET', url: 'https://music-genres-database.p.rapidapi.com/', params: { search: 'jazz', limit: '10' }, headers: { 'X-RapidAPI-Key': 'YOUR_RAPIDAPI_KEY_HERE', 'X-RapidAPI-Host': 'music-genres-database.p.rapidapi.com' } }; async function getJazzGenres() { try { const response = await axios.request(options); console.log('Jazz Genres:', response.data); return response.data; } catch (error) { console.error('Error:', error); } } getJazzGenres(); ``` ### Python ```python import requests url = "https://music-genres-database.p.rapidapi.com/" querystring = {"search": "hip-hop", "limit": "15"} headers = { "X-RapidAPI-Key": "YOUR_RAPIDAPI_KEY_HERE", "X-RapidAPI-Host": "music-genres-database.p.rapidapi.com" } response = requests.get(url, headers=headers, params=querystring) if response.status_code == 200: data = response.json() print(f"Found {data['count']} hip-hop genres:") for genre in data['data']: print(f"- {genre['genre']} (ID: {genre['id']})") print(f" Artists: {genre['representative_artists']}") else: print(f"Error: {response.status_code}") ``` ### PHP ```php <?php $curl = curl_init(); curl_setopt_array($curl, [ CURLOPT_URL => "https://music-genres-database.p.rapidapi.com/?search=metal&limit=10", CURLOPT_RETURNTRANSFER => true, CURLOPT_ENCODING => "", CURLOPT_MAXREDIRS => 10, CURLOPT_TIMEOUT => 30, CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1, CURLOPT_CUSTOMREQUEST => "GET", CURLOPT_HTTPHEADER => [ "X-RapidAPI-Host: music-genres-database.p.rapidapi.com", "X-RapidAPI-Key: YOUR_RAPIDAPI_KEY_HERE" ], ]); $response = curl_exec($curl); $err = curl_error($curl); curl_close($curl); if ($err) { echo "cURL Error #:" . $err; } else { $data = json_decode($response, true); echo "Metal Genres Found: " . $data['count'] . "\n"; foreach ($data['data'] as $genre) { echo "- " . $genre['genre'] . " (ID: " . $genre['id'] . ")\n"; echo " Artists: " . $genre['representative_artists'] . "\n"; } } ?> ``` ### Java ```java import java.io.IOException; import java.net.URI; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; public class MusicGenresAPI { private static final String API_KEY = "YOUR_RAPIDAPI_KEY_HERE"; private static final String API_HOST = "music-genres-database.p.rapidapi.com"; private static final String BASE_URL = "https://music-genres-database.p.rapidapi.com/"; public static void main(String[] args) { try { // Search for electronic genres String url = BASE_URL + "?search=electronic&limit=10"; HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(url)) .header("X-RapidAPI-Key", API_KEY) .header("X-RapidAPI-Host", API_HOST) .method("GET", HttpRequest.BodyPublishers.noBody()) .build(); HttpResponse<String> response = HttpClient.newHttpClient() .send(request, HttpResponse.BodyHandlers.ofString()); System.out.println("Response Status: " + response.statusCode()); System.out.println("Response Body: " + response.body()); } catch (IOException | InterruptedException e) { e.printStackTrace(); } } } ``` ### Ruby ```ruby require 'uri' require 'net/http' require 'json' url = URI("https://music-genres-database.p.rapidapi.com/?search=country&limit=8") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true request = Net::HTTP::Get.new(url) request["X-RapidAPI-Key"] = 'YOUR_RAPIDAPI_KEY_HERE' request["X-RapidAPI-Host"] = 'music-genres-database.p.rapidapi.com' response = http.request(request) if response.code == '200' data = JSON.parse(response.read_body) puts "Country Genres Found: #{data['count']}" data['data'].each do |genre| puts "- #{genre['genre']} (ID: #{genre['id']})" puts " Artists: #{genre['representative_artists']}" end else puts "Error: #{response.code} - #{response.message}" end ``` ### C# ```csharp using System; using System.Net.Http; using System.Threading.Tasks; using Newtonsoft.Json; public class MusicGenresAPI { private static readonly HttpClient client = new HttpClient(); private const string ApiKey = "YOUR_RAPIDAPI_KEY_HERE"; private const string ApiHost = "music-genres-database.p.rapidapi.com"; public static async Task Main(string[] args) { try { // Add headers client.DefaultRequestHeaders.Add("X-RapidAPI-Key", ApiKey); client.DefaultRequestHeaders.Add("X-RapidAPI-Host", ApiHost); // Search for pop genres string url = "https://music-genres-database.p.rapidapi.com/?search=pop&limit=12"; HttpResponseMessage response = await client.GetAsync(url); if (response.IsSuccessStatusCode) { string jsonResponse = await response.Content.ReadAsStringAsync(); dynamic data = JsonConvert.DeserializeObject(jsonResponse); Console.WriteLine($"Pop Genres Found: {data.count}"); foreach (var genre in data.data) { Console.WriteLine($"- {genre.genre} (ID: {genre.id})"); Console.WriteLine($" Artists: {genre.representative_artists}"); } } else { Console.WriteLine($"Error: {response.StatusCode}"); } } catch (Exception ex) { Console.WriteLine($"Exception: {ex.Message}"); } } } ``` ## 🔍 Search Examples ### Popular Genre Searches | Search Term | Example Results | Use Case | |-------------|----------------|----------| | `rock` | Alternative Rock, Arena Rock, Classic Rock | Rock music discovery | | `electronic` | House, Techno, Ambient, Dubstep | Electronic music platforms | | `jazz` | Bebop, Swing, Fusion, Smooth Jazz | Jazz education & streaming | | `hip-hop` | Trap, Conscious Hip-Hop, Boom Bap | Hip-hop categorization | | `classical` | Baroque, Romantic, Contemporary Classical | Classical music apps | | `folk` | Celtic, Americana, World Folk | Folk music exploration | | `metal` | Heavy Metal, Death Metal, Black Metal | Metal music databases | ### Advanced Search Patterns ```javascript // Get all subgenres of a main genre const rockGenres = await fetch('/?search=rock&limit=50'); // Find specific niche genres const ambientGenres = await fetch('/?search=ambient&limit=20'); // Get genres starting with specific letters const aGenres = await fetch('/?search=a&limit=30'); // Pagination through all genres const firstPage = await fetch('/?limit=25&offset=0'); const secondPage = await fetch('/?limit=25&offset=25'); ``` ## ⚡ Rate Limits | Plan | Requests/Month | |------|----------------| | Free | 100 | | Basic | 1,000 | | Pro | 10,000 | | Mega | 100,000 | ## 🚨 Error Codes | Status Code | Error Type | Description | |-------------|------------|-------------| | 200 | Success | Request completed successfully | | 400 | Bad Request | Invalid parameters or malformed request | | 401 | Unauthorized | Missing or invalid API key | | 403 | Forbidden | Rate limit exceeded or subscription expired | | 404 | Not Found | Genre not found or invalid endpoint | | 429 | Too Many Requests | Rate limit exceeded | | 500 | Internal Server Error | Server error, try again later | ### Error Response Format ```json { "success": false, "error": { "code": 400, "message": "Invalid limit parameter. Must be between 1 and 100.", "details": "The 'limit' parameter value '150' exceeds the maximum allowed value of 100." } } ``` ## 📊 Response Format All API responses follow a consistent JSON format: ### Successful Response ```json { "success": true, "count": 5, "data": [ { "id": "genre_id", "genre": "Genre Name", "representative_artists": "Artist 1, Artist 2, Artist 3" } ], "pagination": { "limit": 5, "offset": 0, "total": 47 } } ``` ### Fields Explanation | Field | Type | Description | |-------|------|-------------| | `success` | boolean | Indicates if the request was successful | | `count` | integer | Number of results returned in this response | | `data` | array | Array of genre objects | | `data[].id` | string | Unique identifier for the genre | | `data[].genre` | string | Human-readable genre name | | `data[].representative_artists` | string | Comma-separated list of notable artists | | `pagination.limit` | integer | Number of results requested | | `pagination.offset` | integer | Number of results skipped | | `pagination.total` | integer | Total number of matching results | ## 🎵 Genre Categories The database covers these major music categories: ### Rock & Alternative - Alternative Rock, Classic Rock, Progressive Rock, Punk Rock - Indie Rock, Post-Rock, Psychedelic Rock, Hard Rock ### Electronic & Dance - House, Techno, Trance, Dubstep, Drum & Bass - Ambient, IDM, Breakbeat, Electronica ### Hip-Hop & Rap - East Coast Hip-Hop, West Coast Hip-Hop, Trap - Conscious Hip-Hop, Boom Bap, Southern Hip-Hop ### Pop & Mainstream - Pop Rock, Synth-Pop, Dance-Pop, Indie Pop - Teen Pop, Electropop, Adult Contemporary ### Jazz & Blues - Traditional Jazz, Bebop, Smooth Jazz, Fusion - Chicago Blues, Delta Blues, Electric Blues ### Classical & Orchestral - Baroque, Classical Period, Romantic, Contemporary - Opera, Symphony, Chamber Music, Minimalism ### World & Folk - Celtic, World Music, Folk Rock, Americana - Bluegrass, Country Folk, Traditional Folk ### Metal & Heavy - Heavy Metal, Death Metal, Black Metal, Thrash Metal - Progressive Metal, Power Metal, Doom Metal ## 🔧 Best Practices ### Efficient API Usage 1. **Use Pagination**: Always implement pagination for large datasets ```javascript const getAllGenres = async () => { let allGenres = []; let offset = 0; const limit = 50; while (true) { const response = await fetch(`/?limit=${limit}&offset=${offset}`); const data = await response.json(); allGenres.push(...data.data); if (data.count < limit) break; offset += limit; } return allGenres; }; ``` 2. **Cache Results**: Cache frequently accessed genre data ```javascript const genreCache = new Map(); const getGenreWithCache = async (genreId) => { if (genreCache.has(genreId)) { return genreCache.get(genreId); } const response = await fetch(`/?genre=${genreId}`); const data = await response.json(); genreCache.set(genreId, data); return data; }; ``` 3. **Handle Rate Limits**: Implement retry logic with exponential backoff ```javascript const apiCallWithRetry = async (url, maxRetries = 3) => { for (let i = 0; i < maxRetries; i++) { try { const response = await fetch(url, { headers }); if (response.status === 429) { const delay = Math.pow(2, i) * 1000; await new Promise(resolve => setTimeout(resolve, delay)); continue; } return response; } catch (error) { if (i === maxRetries - 1) throw error; } } }; ``` ### Search Optimization 1. **Use Specific Searches**: More specific searches return better results ```javascript // Good: Specific search const rockGenres = await fetch('/?search=rock&limit=20'); // Better: Very specific search const alternativeRock = await fetch('/?search=alternative%20rock'); ``` 2. **Implement Autocomplete**: Use partial matching for user interfaces ```javascript const autocompleteGenres = async (query) => { if (query.length < 2) return []; const response = await fetch(`/?search=${encodeURIComponent(query)}&limit=10`); const data = await response.json(); return data.data.map(genre => ({ id: genre.id, name: genre.genre, artists: genre.representative_artists })); }; ``` ## 📱 Integration Examples ### React Component ```jsx import React, { useState, useEffect } from 'react'; const GenreExplorer = () => { const [genres, setGenres] = useState([]); const [loading, setLoading] = useState(false); const [searchTerm, setSearchTerm] = useState(''); const searchGenres = async (search) => { setLoading(true); try { const response = await fetch( `https://music-genres-database.p.rapidapi.com/?search=${encodeURIComponent(search)}&limit=20`, { headers: { 'X-RapidAPI-Key': process.env.REACT_APP_RAPIDAPI_KEY, 'X-RapidAPI-Host': 'music-genres-database.p.rapidapi.com' } } ); const data = await response.json(); setGenres(data.data || []); } catch (error) { console.error('Error fetching genres:', error); } finally { setLoading(false); } }; const handleSearch = (e) => { e.preventDefault(); if (searchTerm.trim()) { searchGenres(searchTerm); } }; return (

<form onSubmit={handleSearch}> <input type="text" value={searchTerm} onChange={(e) => setSearchTerm(e.target.value)} placeholder="Search music genres..." className="search-input" /> <button type="submit" disabled={loading}> {loading ? 'Searching...' : 'Search'} </button> </form>

{genres.map((genre) => (

{genre.genre}

Artists: {genre.representative_artists}

))}

); }; export default GenreExplorer; ``` ### Vue.js Component ```vue <template>

Searching genres...

</template> <script> export default { name: 'MusicGenresApp', data() { return { searchQuery: '', genres: [], loading: false, apiKey: process.env.VUE_APP_RAPIDAPI_KEY }; }, methods: { async searchGenres() { if (this.searchQuery.length < 2) { this.genres = []; return; } this.loading = true; try { const response = await fetch( `https://music-genres-database.p.rapidapi.com/?search=${encodeURIComponent(this.searchQuery)}&limit=15`, { headers: { 'X-RapidAPI-Key': this.apiKey, 'X-RapidAPI-Host': 'music-genres-database.p.rapidapi.com' } } ); const data = await response.json(); this.genres = data.data || []; } catch (error) { console.error('Error searching genres:', error); this.genres = []; } finally { this.loading = false; } }, selectGenre(genre) { this.$emit('genre-selected', genre); } } }; </script> ``` ## 🚀 Advanced Features ### Genre Recommendation System ```javascript class GenreRecommendationEngine { constructor(apiKey) { this.apiKey = apiKey; this.baseUrl = 'https://music-genres-database.p.rapidapi.com/'; this.headers = { 'X-RapidAPI-Key': apiKey, 'X-RapidAPI-Host': 'music-genres-database.p.rapidapi.com' }; } async getRelatedGenres(genreId, limit = 10) { try { // Get the specific genre first const genreResponse = await fetch( `${this.baseUrl}?genre=${genreId}`, { headers: this.headers } ); const genreData = await genreResponse.json(); if (!genreData.success || !genreData.data.length) { return []; } const mainGenre = genreData.data[0]; const genreName = mainGenre.genre; // Extract base genre (e.g., "Rock" from "Alternative Rock") const baseGenre = this.extractBaseGenre(genreName); // Search for related genres const relatedResponse = await fetch( `${this.baseUrl}?search=${encodeURIComponent(baseGenre)}&limit=${limit * 2}`, { headers: this.headers } ); const relatedData = await relatedResponse.json(); // Filter out the original genre and return recommendations return relatedData.data .filter(genre => genre.id !== genreId) .slice(0, limit); } catch (error) { console.error('Error getting related genres:', error); return []; } } extractBaseGenre(genreName) { // Simple logic to extract base genre const commonPrefixes = ['Alternative', 'Classic', 'Progressive', 'Modern', 'Traditional']; const commonSuffixes = ['Rock', 'Pop', 'Jazz', 'Blues', 'Metal', 'Hip-Hop']; for (const suffix of commonSuffixes) { if (genreName.includes(suffix)) { return suffix; } } return genreName.split(' ').pop(); // Return last word as fallback } } // Usage const recommender = new GenreRecommendationEngine('YOUR_API_KEY'); const relatedGenres = await recommender.getRelatedGenres('rock_1', 8); console.log('Related to Alternative Rock:', relatedGenres); ``` ### Genre Analytics Dashboard ```javascript class GenreAnalytics { constructor(apiKey) { this.apiKey = apiKey; this.baseUrl = 'https://music-genres-database.p.rapidapi.com/'; this.headers = { 'X-RapidAPI-Key': apiKey, 'X-RapidAPI-Host': 'music-genres-database.p.rapidapi.com' }; } async getGenreDistribution() { try { // Get all genres in batches const allGenres = await this.getAllGenres(); // Analyze genre distribution const distribution = {}; allGenres.forEach(genre => { const baseGenre = this.categorizeGenre(genre.genre); distribution[baseGenre] = (distribution[baseGenre] || 0) + 1; }); return Object.entries(distribution) .map(([category, count]) => ({ category, count })) .sort((a, b) => b.count - a.count); } catch (error) { console.error('Error analyzing genre distribution:', error); return []; } } async getAllGenres() { const allGenres = []; let offset = 0; const limit = 100; while (true) { const response = await fetch( `${this.baseUrl}?limit=${limit}&offset=${offset}`, { headers: this.headers } ); const data = await response.json(); if (!data.success || !data.data.length) break; allGenres.push(...data.data); if (data.data.length < limit) break; offset += limit; } return allGenres; } categorizeGenre(genreName) { const categories = { 'Rock': ['rock', 'punk', 'grunge', 'metal'], 'Electronic': ['electronic', 'techno', 'house', 'ambient', 'dubstep'], 'Hip-Hop': ['hip-hop', 'rap', 'trap', 'beats'], 'Pop': ['pop', 'dance', 'synth'], 'Jazz': ['jazz', 'bebop', 'swing', 'fusion'], 'Classical': ['classical', 'orchestra', 'symphony', 'baroque'], 'Folk': ['folk', 'country', 'bluegrass', 'americana'], 'R&B': ['r&b', 'soul', 'funk', 'neo-soul'] }; const lowerGenre = genreName.toLowerCase(); for (const [category, keywords] of Object.entries(categories)) { if (keywords.some(keyword => lowerGenre.includes(keyword))) { return category; } } return 'Other'; } } // Usage const analytics = new GenreAnalytics('YOUR_API_KEY'); const distribution = await analytics.getGenreDistribution(); console.log('Genre Distribution:', distribution); ``` ## 📈 Performance Optimization ### Caching Strategy ```javascript class GenreCacheManager { constructor(apiKey, cacheTime = 300000) { // 5 minutes default this.apiKey = apiKey; this.cacheTime = cacheTime; this.cache = new Map(); this.headers = { 'X-RapidAPI-Key': apiKey, 'X-RapidAPI-Host': 'music-genres-database.p.rapidapi.com' }; } async getGenres(params) { const cacheKey = this.generateCacheKey(params); const cached = this.cache.get(cacheKey); if (cached && Date.now() - cached.timestamp < this.cacheTime) { return cached.data; } try { const queryString = new URLSearchParams(params).toString(); const response = await fetch( `https://music-genres-database.p.rapidapi.com/?${queryString}`, { headers: this.headers } ); const data = await response.json(); // Cache the result this.cache.set(cacheKey, { data, timestamp: Date.now() }); return data; } catch (error) { console.error('Error fetching genres:', error); throw error; } } generateCacheKey(params) { return Object.entries(params) .sort(([a], [b]) => a.localeCompare(b)) .map(([key, value]) => `${key}=${value}`) .join('&'); } clearCache() { this.cache.clear(); } getCacheStats() { return { size: this.cache.size, entries: Array.from(this.cache.keys()) }; } } ``` ### Batch Processing ```javascript class GenreBatchProcessor { constructor(apiKey, concurrency = 5) { this.apiKey = apiKey; this.concurrency = concurrency; this.headers = { 'X-RapidAPI-Key': apiKey, 'X-RapidAPI-Host': 'music-genres-database.p.rapidapi.com' }; } async processGenresBatch(genreIds) { const batches = this.createBatches(genreIds, this.concurrency); const results = []; for (const batch of batches) { const batchResults = await Promise.all( batch.map(genreId => this.getGenreDetails(genreId)) ); results.push(...batchResults.filter(result => result !== null)); // Add delay between batches to respect rate limits await this.delay(100); } return results; } async getGenreDetails(genreId) { try { const response = await fetch( `https://music-genres-database.p.rapidapi.com/?genre=${genreId}`, { headers: this.headers } ); const data = await response.json(); return data.success ? data.data[0] : null; } catch (error) { console.error(`Error fetching genre ${genreId}:`, error); return null; } } createBatches(array, batchSize) { const batches = []; for (let i = 0; i < array.length; i += batchSize) { batches.push(array.slice(i, i + batchSize)); } return batches; } delay(ms) { return new Promise(resolve => setTimeout(resolve, ms)); } } ``` ## 🔒 Security Best Practices ### API Key Management ```javascript // Environment-based configuration const config = { apiKey: process.env.RAPIDAPI_KEY, apiHost: 'music-genres-database.p.rapidapi.com', baseUrl: 'https://music-genres-database.p.rapidapi.com/' }; // Validate API key before making requests function validateApiKey(apiKey) { if (!apiKey) { throw new Error('RapidAPI key is required'); } if (typeof apiKey !== 'string' || apiKey.length < 20) { throw new Error('Invalid RapidAPI key format'); } return true; } // Secure API client class SecureGenreClient { constructor(apiKey) { validateApiKey(apiKey); this.apiKey = apiKey; this.rateLimiter = new RateLimiter(60, 60000); // 60 requests per minute } async makeRequest(endpoint, params = {}) { await this.rateLimiter.checkLimit(); const queryString = new URLSearchParams(params).toString(); const url = `${config.baseUrl}${endpoint}${queryString ? '?' + queryString : ''}`; try { const response = await fetch(url, { headers: { 'X-RapidAPI-Key': this.apiKey, 'X-RapidAPI-Host': config.apiHost } }); if (!response.ok) { throw new Error(`HTTP ${response.status}: ${response.statusText}`); } return await response.json(); } catch (error) { console.error('API request failed:', error); throw error; } } } class RateLimiter { constructor(maxRequests, timeWindow) { this.maxRequests = maxRequests; this.timeWindow = timeWindow; this.requests = []; } async checkLimit() { const now = Date.now(); this.requests = this.requests.filter(time => now - time < this.timeWindow); if (this.requests.length >= this.maxRequests) { const waitTime = this.timeWindow - (now - this.requests[0]); await new Promise(resolve => setTimeout(resolve, waitTime)); return this.checkLimit(); } this.requests.push(now); } } ``` ## 🎯 Production Deployment ### Docker Configuration ```dockerfile # Dockerfile for a Node.js app using Music Genres Database API FROM node:18-alpine WORKDIR /app # Copy package files COPY package*.json ./ # Install dependencies RUN npm ci --only=production # Copy application code COPY . . # Set environment variables ENV NODE_ENV=production ENV RAPIDAPI_KEY="" # Expose port EXPOSE 3000 # Health check HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ CMD curl -f http://localhost:3000/health || exit 1 # Start the application CMD ["npm", "start"] ``` ### Environment Configuration ```bash # .env.production NODE_ENV=production RAPIDAPI_KEY=your_production_rapidapi_key_here API_TIMEOUT=5000 CACHE_TTL=300000 RATE_LIMIT_MAX=1000 RATE_LIMIT_WINDOW=60000 LOG_LEVEL=info ``` ### Monitoring Setup ```javascript // monitoring.js const client = require('prom-client'); // Create metrics const apiRequestsTotal = new client.Counter({ name: 'music_genres_api_requests_total', help: 'Total number of API requests', labelNames: ['method', 'endpoint', 'status'] }); const apiRequestDuration = new client.Histogram({ name: 'music_genres_api_request_duration_seconds', help: 'API request duration in seconds', labelNames: ['method', 'endpoint'] }); const apiCacheHits = new client.Counter({ name: 'music_genres_api_cache_hits_total', help: 'Total number of cache hits' }); // Middleware for Express.js function metricsMiddleware(req, res, next) { const start = Date.now(); res.on('finish', () => { const duration = (Date.now() - start) / 1000; apiRequestsTotal .labels(req.method, req.path, res.statusCode) .inc(); apiRequestDuration .labels(req.method, req.path) .observe(duration); }); next(); } module.exports = { metricsMiddleware, apiCacheHits, register: client.register }; ``` ## 🎵 Genre Data Insights ### Popular Genre Categories Based on our comprehensive database analysis: | Category | Genre Count | Popular Examples | |----------|-------------|------------------| | **Rock** | 87 genres | Alternative Rock, Classic Rock, Progressive Rock | | **Electronic** | 64 genres | House, Techno, Ambient, Dubstep | | **Hip-Hop** | 45 genres | East Coast Hip-Hop, Trap, Conscious Hip-Hop | | **Pop** | 38 genres | Dance-Pop, Synth-Pop, Indie Pop | | **Jazz** | 32 genres | Bebop, Smooth Jazz, Fusion | | **Metal** | 29 genres | Heavy Metal, Death Metal, Progressive Metal | | **Folk** | 28 genres | Celtic, Americana, World Folk | | **Classical** | 25 genres | Baroque, Romantic, Contemporary Classical | ### Emerging Genres Stay updated with the latest music trends: - **Future Bass** - Modern electronic with melodic drops - **Lo-Fi Hip-Hop** - Chill, atmospheric hip-hop beats - **Synthwave** - 80s-inspired electronic music - **Math Rock** - Complex, technical rock compositions - **Vaporwave** - Nostalgic, dreamy electronic aesthetics ## 🤝 Support & Community ### Getting Help - **Documentation**: Comprehensive guides and examples - **RapidAPI Support**: Technical support through RapidAPI platform - **Status Page**: Real-time API status and uptime monitoring - **Community Forum**: Connect with other developers ### Feature Requests We're constantly improving the Music Genres Database API. Submit feature requests through: 1. RapidAPI platform feedback system 2. GitHub discussions (if available) 3. Direct contact through API dashboard ### Updates & Changelog - **v1.0.0** - Initial release with 630+ genres - Regular updates with new genres and improvements - Performance optimizations and bug fixes --- ## 📄 License & Terms This API is provided under RapidAPI's standard terms of service. By using this API, you agree to: - Use the API responsibly and within rate limits - Not attempt to reverse engineer or copy the database - Respect intellectual property rights - Follow RapidAPI's community guidelines --- **Ready to explore the world of music genres? Get started with the Music Genres Database API today!** 🎵 Happy coding and music discovery! 🎵

{genre.genre}

{{ genre.genre }}