Launch Sale: Creator and Business plans are discounted for a limited time. View pricing

Get Started

Choose the AudioDN setup that fits your product.

Every AudioDN workflow begins the same way: define the files and data your product needs from each audio upload. From there, you can use AudioDN’s components, APIs, native integrations, or a combination of them.

Whether you need a five-minute web integration or complete server-side control, this page will help you choose the right path.

Build your setup Create an account
Browse all documentation

First, decide what each upload should become.

AudioDN processes every uploaded file using the variants configured for your account or collection. Configure these outputs once, and AudioDN creates them automatically whenever new audio arrives.

One unpredictable source upload

Any format, quality, or bitrate

song.wav • Lossless
AudioDN processing
  • Reliable playback High-quality AAC or MP3
  • Low-bandwidth playback Opus or AAC
  • Preview 30-second preview clip
  • Download FLAC or WAV download
  • Waveform or analysis Waveform images and analysis data
  • Original Preserved when retained

A source file can become several purpose-built outputs. Customer-facing outcomes come first; codec and bitrate choices are just supporting detail.

Create only the outputs your product needs. You can add more variants as your workflow evolves.

Retaining the original upload lets AudioDN generate new variants later, so you can add an output without asking customers to re-upload.

Explore variant types Configure variants in the dashboard

Once AudioDN knows what to create, choose how it connects to your product.

Your industry does not determine your integration. The most important questions are how much interface you want AudioDN to provide, where your business rules live, and how much control your team wants over the workflow.

How do you want to build?

These are starting architectures, not product plans. You can combine approaches, and you can change your mind later. Start with the architecture that fits today — add more control as your product grows.

Help me choose

Answer up to three questions and we will highlight a recommended architecture and playback method. This is optional — if you already know what you need, select it above.

Do you want to use AudioDN’s uploader or player interface?
Does your server need to approve uploads or playback?
Is the audio public or access-controlled?

Recommended architecture

Web Components

Why it fits

Add uploading and playback with maintained web components and scoped client-side credentials. No application backend is required.

Upload approach

The AudioDN uploader component sends files directly, authorized by a scoped Client-Side Upload key.

Playback approach

The AudioDN player component uses a scoped Client-Side Player key and renews playback sessions automatically.

Credential or session model

  • Client-Side Upload key
  • Client-Side Player key

AudioDN handles

  • Upload interface
  • Player interface
  • Session creation
  • Direct audio upload
  • Playback delivery
  • Variant selection

Your team handles

  • Page layout
  • Product content
  • Collection configuration
  • Choosing which audio is displayed

Conceptual flow

  1. User
  2. AudioDN component
  3. Scoped Client-Side key
  4. AudioDN upload or playback session
See the basic flow 
<script type="module">
  import '@audiodn/components/uploader'
  import '@audiodn/components/player'
</script>

<audiodn-uploader
  api-key="CLIENT_SIDE_UPLOAD_KEY"
  collection-id="COLLECTION_ID"
></audiodn-uploader>

<audiodn-player
  api-key="CLIENT_SIDE_PLAYER_KEY"
  scope="collection"
  id="COLLECTION_ID"
></audiodn-player>
View the Web integration guide

Recommended architecture

Hybrid

Why it fits

Your server decides who can upload or listen, creates short-lived upload or play sessions, and passes those session IDs to AudioDN's uploader or player components.

Upload approach

Your server creates a short-lived upload session after your checks, then passes it to the AudioDN uploader component.

Playback approach

Your server creates a short-lived play session after your checks, then passes it to the AudioDN player component.

Credential or session model

  • API Access key stays on the server
  • Short-lived upload or play session IDs are passed to the client
  • No long-lived Client-Side API key is required in the frontend for that session-based flow

AudioDN handles

  • Upload interface
  • Player interface
  • Direct file transfer
  • Processing
  • Storage
  • Secure delivery

Your team handles

  • Authentication
  • Subscription checks
  • Purchase validation
  • Entitlements
  • Account permissions
  • Deciding when sessions may be created

Conceptual flow

  1. User
  2. Your application
  3. Your server checks access
  4. Your server creates an AudioDN session
  5. AudioDN component uploads or plays audio
See the basic flow 
// On your server, after authorizing the user:
const res = await fetch('https://api.audiodelivery.net/v1/play_session/collection', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer ' + process.env.ADN_API_KEY,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ collection_id, variants: ['hq'], expires_in: 3600 }),
});
const { play_session_id } = await res.json();

// On the client, hand the session to the component:
// <audiodn-player play-session-id="PLAY_SESSION_ID"></audiodn-player>
View the Hybrid integration guide

Recommended architecture

Full API

Why it fits

Use AudioDN as a headless audio-processing and delivery backend. Manage uploads, tracks, collections, sessions, metadata, and playback through the API while maintaining a completely custom frontend.

Upload approach

Your server creates upload sessions and transfers files directly through the API, wrapped in your own interface.

Playback approach

Your server creates play sessions or signed delivery URLs and plays variants through your own interface.

Credential or session model

  • Server-side API Access key
  • Upload sessions
  • Play sessions or signed delivery URLs

AudioDN handles

  • Direct upload infrastructure
  • Audio inspection
  • Variant processing
  • Storage
  • Delivery
  • Track lifecycle
  • Webhook notifications

Your team handles

  • Upload interface
  • Player interface
  • Application workflow
  • Authorization logic
  • Product-specific data and presentation

Conceptual flow

  1. Your interface
  2. Your server
  3. AudioDN API
  4. Processing and delivery
See the basic flow 
// 1. Create an upload session (returns an ID, not an upload URL).
const res = await fetch('https://api.audiodelivery.net/v1/upload_session', {
  method: 'POST',
  headers: {
    Authorization: 'Bearer ' + process.env.ADN_API_KEY,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ collection_id, expires_in: 3600 }),
});
const { upload_session_id } = await res.json();

// 2. Create a track in the session to get its signed upload URL
//    (one request per file; the session ID authorizes it).
const trackRes = await fetch(
  `https://api.audiodelivery.net/v1/upload/${upload_session_id}/track`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ file_name: 'song.wav' }),
  },
);
const { track_id, track_upload } = await trackRes.json();

// 3. Upload the bytes, then poll GET /v1/track/{track_id} (or use a webhook)
//    until track_status_id is "ready" before playback.
View the Server-Side integration guide Open the API reference

Recommended architecture

Native Mobile

Why it fits

Upload through AudioDN sessions and play processed variants using native application audio frameworks.

Upload approach

Create an upload session and transfer the file from the app, either with a scoped client-side key or a server-provisioned session.

Playback approach

Fetch signed playback resources or create play sessions, then play variants with the native media player.

Credential or session model

  • Scoped Client-Side keys for straightforward native integrations
  • Server-provisioned sessions when the product requires backend authorization

AudioDN handles

  • Upload sessions
  • Direct file transfer
  • Processing
  • Variant delivery
  • Signed playback resources

Your team handles

  • Native interface
  • Media controls
  • Local application state
  • Platform-specific playback behavior

Conceptual flow

  1. Native application
  2. AudioDN session APIs
  3. Native upload or media player
See the basic flow 
// Create an upload session from your app or server, then transfer the file.
var request = URLRequest(url: URL(string: "https://api.audiodelivery.net/v1/upload_session")!)
request.httpMethod = "POST"
request.setValue("Bearer " + apiKey, forHTTPHeaderField: "Authorization")
// ...upload the file, then play processed variants with AVPlayer.
View the Mobile integration guide

Decide how listeners receive audio.

Uploading and playback do not have to use the same access model. Choose the playback method that matches whether your audio is public, privately scoped, purchased, or subscription-controlled.

Learn about Web playback
Learn about Play Sessions
View Signed Delivery Read the Signing Keys reference

Use a play session when your server must decide whether this listener may access the audio.

Use a signed URL when your server has already decided that the audio may be shared and no per-play API authorization is needed.

You can use more than one playback method.

A product might use signed delivery for public previews, server-created play sessions for purchased full-length audio, and Client-Side Player keys for an internal catalog. AudioDN does not force the entire product into one access model.

Your starting plan

Your AudioDN starting plan

A plan for your selected architecture and playback method. Change your selections above to update these steps.

Authorize the listener with your own business rules before creating each play session.
Signed delivery is a playback and delivery option, not a complete integration. You still need one of the upload methods above to ingest audio.
  1. Configure your variants Choose the playback, preview, download, waveform, and original-file outputs AudioDN should create. Variant types
  2. Create a collection Use a collection to group audio and apply the appropriate configuration and access scope. Collections API
  3. Create a Client-Side Upload key Create a scoped Client-Side Upload key for the collection your uploader should write to. Web integration guide
  4. Add the AudioDN uploader component Drop the uploader into your page with your upload key. Files transfer directly to AudioDN. Uploader component
  5. Create a server-side API Access key Keep this credential on the server. API keys reference
  6. Provision upload sessions After applying the customer’s upload permissions, create a short-lived upload session and pass it to the AudioDN uploader. Upload sessions
  7. Receive processing updates Use the track-processing webhook to learn when all configured variants are ready. Track-processing webhook
  8. Create a server-side API Access key Keep this credential on the server. API keys reference
  9. Provision upload sessions Create a short-lived upload session and transfer files directly through the API. Upload sessions
  10. Receive processing updates Use the track-processing webhook to learn when all configured variants are ready. Track-processing webhook
  11. Build your own upload interface Wrap the upload flow in your own UI and application workflow. Server-Side integration guide
  12. Create your credentials Use scoped Client-Side keys for straightforward apps, or server-provisioned sessions when you need backend authorization. API keys reference
  13. Create an upload session Create a short-lived upload session and transfer the file from the app. Upload sessions
  14. Receive processing updates Use the track-processing webhook to learn when all configured variants are ready. Track-processing webhook
  15. Create a Client-Side Player key Scope it to the tracks, collections, playlists, or variants the player may access. API keys reference
  16. Add the AudioDN player component The player creates and renews play sessions automatically. Player component
  17. Provision play sessions After checking a login, subscription, purchase, or entitlement, create a play session. Play sessions
  18. Deliver playback Pass the play session to the AudioDN player, or retrieve the available files for a custom player. Play sessions
  19. Create a URL Signing key Keep the signing secret on your server. Signing keys reference
  20. Sign delivery URLs on your server Create time-limited URLs and hand them to the client for direct delivery. Signed Delivery

Already know what you need?

Skip the selector and jump straight into the relevant documentation.

Common AudioDN setups

A few starting points that combine the pieces above. These are examples, not the only way to build.

Public media catalog

  • Web Components or custom API interface
  • Client-Side Player key or signed delivery
  • High- and low-quality playback variants

SaaS or marketplace

  • Hybrid uploader and player
  • Server-created sessions
  • Account- or customer-specific collections
  • Processing webhooks

Paid audio or downloads

  • Hybrid or Full API
  • Preview variants
  • Server-created play sessions for protected audio
  • Download permissions
  • Optional signed delivery for public previews

Custom processing pipeline

  • Full API
  • Upload sessions
  • Configured transcoding, analysis, or download variants
  • Processing webhooks
  • Custom frontend or no AudioDN frontend at all

Start with the path that fits. AudioDN can grow with you.

Configure the outputs your product needs, choose the level of control that makes sense today, and connect the rest when you are ready.

Create an AudioDN account Open the documentation Talk to sales