Audiomack API in 2026: How to Access Independent and Afrobeats Music Data

What Is Audiomack and Why Developers Care

Audiomack is a free music streaming platform built around independent artists, Afrobeats, hip-hop, and R&B. It has over 20 million monthly active users, with a particularly strong presence in West Africa, the Caribbean, and the United States. Artists upload directly to the platform without label gatekeeping, which creates a catalog that skews heavily toward emerging and independent music.

For developers, this matters for three reasons:

• Unique catalog coverage. Audiomack hosts tracks and mixtapes that are not available on mainstream streaming services. If your app targets indie music discovery or Afrobeats listeners, Audiomack fills a gap that no other single platform covers.
• Growing user base in underserved markets. West African and Caribbean music markets are expanding rapidly. Apps that connect to Audiomack can serve these audiences with localized content they actually listen to.
• Creator-first metadata. Because artists self-upload, Audiomack's catalog includes metadata and playlist structures that reflect grassroots listening patterns rather than label-curated recommendations.

If you are building a playlist migration tool, a cross-platform music library, or an analytics dashboard, skipping Audiomack means missing a significant slice of the independent music ecosystem.

Audiomack API Landscape in 2026

Audiomack provides developer access to its platform data, but the integration path has historically required direct API work: managing OAuth credentials, handling token refresh cycles, and parsing response formats that differ from every other streaming service you support.

The core data you can access through Audiomack includes:

Data Type	What You Get
User profiles	Display name, verified status, follower/following counts
User playlists	All playlists created or followed by a user
Playlist tracks	Full track listings with artist, title, and duration
Favorite tracks	Songs a user has explicitly favorited
Playlist metadata	Title, description, track count, creator info

The challenge is not availability. The challenge is integration cost. Every streaming service you add to your app means another OAuth flow to build, another token refresh cycle to manage, another response schema to normalize. Audiomack is no exception. Its API returns data in its own format, with its own authentication requirements, and its own rate limiting rules.

This is where a unified API approach saves significant engineering time. Instead of building and maintaining a direct Audiomack integration alongside every other service, you connect once and access Audiomack data through the same endpoints you already use for other platforms.

Accessing Audiomack Data Through MusicAPI

MusicAPI provides a single integration point for 10+ streaming services, including Audiomack. You write one set of API calls, and MusicAPI handles the per-service OAuth, token management, and response normalization behind the scenes.

Here is how it works for Audiomack specifically.

Authentication Flow

MusicAPI manages Audiomack's OAuth flow through a unified authentication process. You do not need to register a separate Audiomack developer app or handle its tokens directly.

1. Call the authentication initialization endpoint and include Audiomack in your service list.
2. The user authorizes access on Audiomack's consent screen.
3. MusicAPI sends a callback to your server with a unified user token.
4. Use that token for all subsequent Audiomack data requests.

const response = await fetch('https://api.musicapi.com/auth/init', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    services: ['audiomack'],
    callbackUrl: 'https://yourapp.com/api/auth/callback',
    userId: 'user_456'
  })
});

const { authUrl } = await response.json();
// Redirect user to authUrl to connect their Audiomack account

The same flow works if you want to connect Audiomack alongside other services. Just add them to the services array. MusicAPI handles each OAuth handshake independently and returns a single callback when all connections are complete.

For details on retrieving the raw Audiomack OAuth tokens (useful for direct platform calls), see the original auth tokens documentation.

Fetching Playlists and Tracks

Once a user has connected their Audiomack account, pulling their playlists and tracks works exactly like any other service in MusicAPI. The endpoints are the same; only the service parameter changes.

Fetch a user's Audiomack playlists:

const playlists = await fetch(
  `https://api.musicapi.com/users/${userId}/playlists/audiomack`,
  {
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
  }
);

const data = await playlists.json();
// data.playlists contains normalized playlist objects

Each playlist object includes a consistent set of fields: id, title, description, trackCount, and creator. These fields are identical whether the playlist comes from Audiomack or any other supported service.

To get the tracks inside a specific playlist, use the playlist tracks endpoint:

const tracks = await fetch(
  `https://api.musicapi.com/playlists/${playlistId}/tracks/audiomack`,
  {
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
  }
);

const trackData = await tracks.json();
// trackData.tracks contains normalized track objects

For more on what each endpoint returns and which actions are supported per service, check the supported features matrix.

User Profile Data

Fetching an Audiomack user's profile follows the same pattern. The user profile endpoint returns normalized profile data:

const profile = await fetch(
  `https://api.musicapi.com/users/${userId}/profile/audiomack`,
  {
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
  }
);

const profileData = await profile.json();
// profileData includes displayName, profileUrl, followerCount, etc.

This is particularly useful for apps that display user identity across multiple platforms. You can pull profiles from Audiomack and other services using the same response shape, making it straightforward to render a unified "connected accounts" view in your UI.

Code Example: Pulling Audiomack Playlist Tracks

Here is a complete, working example that authenticates a user, fetches their Audiomack playlists, and retrieves the tracks from each playlist. This is the kind of integration that would take days to build directly against Audiomack's API but takes minutes through MusicAPI.

// Full example: Fetch all Audiomack playlist tracks for a user

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://api.musicapi.com';

async function getAudiomackLibrary(userId) {
  const headers = {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json'
  };

  // Step 1: Get all user playlists from Audiomack
  const playlistRes = await fetch(
    `${BASE_URL}/users/${userId}/playlists/audiomack`,
    { headers }
  );
  const { playlists } = await playlistRes.json();

  console.log(`Found ${playlists.length} Audiomack playlists`);

  // Step 2: Fetch tracks for each playlist in parallel
  const playlistsWithTracks = await Promise.all(
    playlists.map(async (playlist) => {
      const trackRes = await fetch(
        `${BASE_URL}/playlists/${playlist.id}/tracks/audiomack`,
        { headers }
      );
      const { tracks } = await trackRes.json();

      return {
        title: playlist.title,
        trackCount: tracks.length,
        tracks: tracks.map(t => ({
          title: t.title,
          artist: t.artist,
          duration: t.duration
        }))
      };
    })
  );

  // Step 3: Aggregate stats
  const totalTracks = playlistsWithTracks.reduce(
    (sum, p) => sum + p.trackCount, 0
  );

  return {
    userId,
    service: 'audiomack',
    playlistCount: playlists.length,
    totalTracks,
    playlists: playlistsWithTracks
  };
}

// Usage
const library = await getAudiomackLibrary('user_456');
console.log(`Total Audiomack tracks: ${library.totalTracks}`);
library.playlists.forEach(p => {
  console.log(`  ${p.title}: ${p.trackCount} tracks`);
});

MusicAPI handles Audiomack's OAuth token refresh, rate limiting, and response normalization automatically. You write the code above once, and it works the same way for any supported service. Swap 'audiomack' for 'spotify' or 'tidal' and the response shape stays identical.

Audiomack vs Other Indie Music Platforms

When choosing which indie music platforms to integrate, the decision comes down to catalog coverage, API access, and audience overlap. Here is how the major indie-focused platforms compare on the metrics that matter to developers.

Feature	Audiomack	Platform B	Platform C
Primary genre focus	Afrobeats, hip-hop, R&B, indie	Electronic, indie, all genres	Indie, experimental, all genres
Free streaming tier	Yes (ad-supported)	Yes (limited)	Purchase/stream hybrid
User playlist access	Yes	Yes	No
User profile data	Yes	Yes	Limited
Favorite/saved tracks	Yes	Yes (likes)	Yes (collection)
Artist self-upload	Yes	Yes	Yes
African market strength	Very strong	Moderate	Weak
Unified API access via MusicAPI	Yes	Yes	No

Audiomack stands out for Afrobeats and African market coverage. If your app targets listeners in Nigeria, Ghana, Kenya, or the broader African diaspora, Audiomack is the platform those users are most likely to have active accounts on. It is also the strongest option for hip-hop mixtapes and independent rap releases.

For apps that need to cover the broadest possible indie catalog, integrating multiple platforms through a unified API is the practical path. You get Audiomack's unique catalog alongside other platforms through a single set of endpoints, without multiplying your integration maintenance burden.

FAQ

What data can I access through the Audiomack API?

You can access user profiles, playlists, playlist tracks, and favorite tracks. This covers the core data most music apps need: who the user is, what they listen to, and how they organize their music. Through MusicAPI, all of this data comes back in a normalized format that matches every other supported service. See the full endpoints reference for details.

Do I need a separate Audiomack developer account to use the API?

Not if you use MusicAPI. MusicAPI handles the Audiomack OAuth integration on your behalf, so you do not need to register a separate Audiomack developer application. You authenticate users through MusicAPI's unified auth flow, and it manages the Audiomack credentials behind the scenes.

Is the Audiomack API free to use?

Accessing Audiomack data through MusicAPI is included in your MusicAPI plan. Check the pricing page for plan details, rate limits, and the number of connected users included at each tier.

Can I use the Audiomack API for playlist migration?

Yes. You can read a user's playlists and tracks from Audiomack, then write those tracks to another platform's playlist using MusicAPI's create playlist endpoints. This is one of the most common use cases: letting users move their music libraries between services without manual re-creation.

How does Audiomack's rate limiting work through MusicAPI?

MusicAPI manages rate limiting for all supported services, including Audiomack. You do not need to track Audiomack-specific throttling rules. MusicAPI queues and retries requests as needed to stay within platform limits. For your own API usage, rate limits depend on your plan tier. See the rate limiting documentation for specifics.

What makes Audiomack different from other streaming platforms for developers?

Audiomack's catalog is heavily weighted toward independent artists, Afrobeats, and hip-hop mixtapes. This makes it uniquely valuable for apps targeting indie music discovery, African music markets, or hip-hop culture. The platform's free streaming model also means its user base skews toward listeners who may not subscribe to premium tiers on other services, giving you access to an audience segment that other platforms miss.

Can I access Audiomack data alongside other streaming services in one API call?

MusicAPI normalizes responses across all supported services, so the same endpoint structure works for Audiomack and other platforms. You call the same playlist or profile endpoint with a different service parameter. This lets you build cross-platform features (like library comparison or unified search) without writing service-specific code for each platform.

---

Ready to skip months of OAuth and SDK work? Start your free MusicAPI trial and connect 10+ streaming services with one unified API. Check out the supported services page to see every platform available through a single integration.