Audio Converter API

Convert Between All Major Audio Formats with Speed and Precision.

Get Started Documentation Go to
hero banner

Code Examples in Popular Languages

Integrate our Audio Converter API easily into your apps with comprehensive code examples in popular languages to get started quickly.

CURL Request 
curl --location 'https://theonlineconverter.com/api/v1/audio-converter' \
--header 'Content-Type: application/json' \
--header 'x-api-key: enter_your_api_key' \
--form 'from="enter_supported_format"' \
--form 'to="enter_supported_format"' \
--form 'file=@"/D:/data/Audio/aac/sample1.aac"' \
--form 'cut_from=""' \
--form 'cut_to=""' \
--form 'audio_codec="pcm_s16le"' \
--form 'audio_channel=""' \
--form 'frequency=""' \
--form 'volume=""'
JavaScript Fetch 
const myHeaders = new Headers();
myHeaders.append("Content-Type", "application/json");
myHeaders.append("x-api-key", "enter_your_api_key");

const formdata = new FormData();
formdata.append("from", "enter_supported_format");
formdata.append("to", "enter_supported_format");
formdata.append("file", fileInput.files[0], "/D:/data/Audio/aac/sample1.aac");
formdata.append("cut_from", "");
formdata.append("cut_to", "");
formdata.append("audio_codec", "pcm_s16le");
formdata.append("audio_channel", "");
formdata.append("frequency", "");
formdata.append("volume", "");

const requestOptions = {
  method: "POST",
  headers: myHeaders,
  body: formdata,
  redirect: "follow"
};

fetch("https://theonlineconverter.com/api/v1/audio-converter", requestOptions)
  .then((response) => response.text())
  .then((result) => console.log(result))
  .catch((error) => console.error(error));
Ruby Net::HTTP 
import requests
import json

url = "https://theonlineconverter.com/api/v1/audio-converter"

payload = {'from': 'enter_supported_format',
'to': 'enter_supported_format',
'cut_from': '',
'cut_to': '',
'audio_codec': 'pcm_s16le',
'audio_channel': '',
'frequency': '',
'volume': ''}
files=[
  ('file',('sample1.aac',open('/D:/data/Audio/aac/sample1.aac','rb'),'audio/aac'))
]
headers = {
  'Content-Type': 'application/json',
  'x-api-key': 'enter_your_api_key'
}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)
Python Requests 
import requests
import json

url = "https://theonlineconverter.com/api/v1/audio-converter"

payload = {'from': 'enter_supported_format',
'to': 'enter_supported_format',
'cut_from': '',
'cut_to': '',
'audio_codec': 'pcm_s16le',
'audio_channel': '',
'frequency': '',
'volume': ''}
files=[
  ('file',('sample1.aac',open('/D:/data/Audio/aac/sample1.aac','rb'),'audio/aac'))
]
headers = {
  'Content-Type': 'application/json',
  'x-api-key': 'enter_your_api_key'
}

response = requests.request("POST", url, headers=headers, data=payload, files=files)

print(response.text)
PHP Guzzle 
<?php
$client = new Client();
$headers = [
  'Content-Type' => 'application/json',
  'x-api-key' => 'enter_your_api_key'
];
$options = [
  'multipart' => [
    [
      'name' => 'from',
      'contents' => 'enter_supported_format'
    ],
    [
      'name' => 'to',
      'contents' => 'enter_supported_format'
    ],
    [
      'name' => 'file',
      'contents' => Utils::tryFopen('/D:/data/Audio/aac/sample1.aac', 'r'),
      'filename' => '/D:/data/Audio/aac/sample1.aac',
      'headers'  => [
        'Content-Type' => '<Content-type header>'
      ]
    ],
    [
      'name' => 'cut_from',
      'contents' => ''
    ],
    [
      'name' => 'cut_to',
      'contents' => ''
    ],
    [
      'name' => 'audio_codec',
      'contents' => 'pcm_s16le'
    ],
    [
      'name' => 'audio_channel',
      'contents' => ''
    ],
    [
      'name' => 'frequency',
      'contents' => ''
    ],
    [
      'name' => 'volume',
      'contents' => ''
    ]
]];
$request = new Request('POST', 'https://theonlineconverter.com/api/v1/audio-converter', $headers);
$res = $client->sendAsync($request, $options)->wait();
echo $res->getBody();
Java HttpURLConnection 
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
  .addFormDataPart("from","enter_supported_format")
  .addFormDataPart("to","enter_supported_format")
  .addFormDataPart("file","/D:/data/Audio/aac/sample1.aac",
    RequestBody.create(MediaType.parse("application/octet-stream"),
    new File("/D:/data/Audio/aac/sample1.aac")))
  .addFormDataPart("cut_from","")
  .addFormDataPart("cut_to","")
  .addFormDataPart("audio_codec","pcm_s16le")
  .addFormDataPart("audio_channel","")
  .addFormDataPart("frequency","")
  .addFormDataPart("volume","")
  .build();
Request request = new Request.Builder()
  .url("https://theonlineconverter.com/api/v1/audio-converter")
  .method("POST", body)
  .addHeader("Content-Type", "application/json")
  .addHeader("x-api-key", "enter_your_api_key")
  .build();
Response response = client.newCall(request).execute();
Go net/http 
package main

import (
  "fmt"
  "bytes"
  "mime/multipart"
  "os"
  "path/filepath"
  "net/http"
  "io"
)

func main() {

  url := "https://theonlineconverter.com/api/v1/audio-converter"
  method := "POST"

  payload := &bytes.Buffer{}
  writer := multipart.NewWriter(payload)
  _ = writer.WriteField("from", "enter_supported_format")
  _ = writer.WriteField("to", "enter_supported_format")
  file, errFile3 := os.Open("/D:/data/Audio/aac/sample1.aac")
  defer file.Close()
  part3,
         errFile3 := writer.CreateFormFile("file",filepath.Base("/D:/data/Audio/aac/sample1.aac"))
  _, errFile3 = io.Copy(part3, file)
  if errFile3 != nil {
    fmt.Println(errFile3)
    return
  }
  _ = writer.WriteField("cut_from", "")
  _ = writer.WriteField("cut_to", "")
  _ = writer.WriteField("audio_codec", "pcm_s16le")
  _ = writer.WriteField("audio_channel", "")
  _ = writer.WriteField("frequency", "")
  _ = writer.WriteField("volume", "")
  err := writer.Close()
  if err != nil {
    fmt.Println(err)
    return
  }


  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")
  req.Header.Add("x-api-key", "enter_your_api_key")

  req.Header.Set("Content-Type", writer.FormDataContentType())
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
C# HttpClient 
var options = new RestClientOptions("https://theonlineconverter.com")
{
  MaxTimeout = -1,
};
var client = new RestClient(options);
var request = new RestRequest("/api/v1/audio-converter", Method.Post);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("x-api-key", "enter_your_api_key");
request.AlwaysMultipartFormData = true;
request.AddParameter("from", "enter_supported_format");
request.AddParameter("to", "enter_supported_format");
request.AddFile("file", "/D:/data/Audio/aac/sample1.aac");
request.AddParameter("cut_from", "");
request.AddParameter("cut_to", "");
request.AddParameter("audio_codec", "pcm_s16le");
request.AddParameter("audio_channel", "");
request.AddParameter("frequency", "");
request.AddParameter("volume", "");
RestResponse response = await client.ExecuteAsync(request);
Console.WriteLine(response.Content);

Key Features & Capabilities

Our API is engineered for high-fidelity sound, broad compatibility, and powerful performance.

Simple User Interface

Extensive Format Support

Convert between all popular audio formats, including lossy (MP3, AAC, OGG, M4A) and lossless (WAV, FLAC, ALAC) codecs.

Simple Data Format

Video to Audio Extraction

Easily extract the audio track from video files. Convert MP4, MOV, AVI, and other video formats directly into an MP3 or WAV audio file.

Time

Full Audio Quality Control

Fine-tune your output by specifying the audio bitrate, sample rate, and channels (mono/stereo) to meet your exact quality and file size requirements.

Secure Data

Metadata Preservation

Retain important metadata during conversion, including track title, artist, album, and cover art, ensuring your audio files remain organized.

Universal Access

Audio Normalization

Automatically adjust the volume of your audio files to a standard level, ensuring a consistent listening experience across multiple tracks.

Freedom

Secure & Confidential

All audio files are processed over encrypted connections. We guarantee confidentiality with a strict data privacy policy and do not store your files.

Frequently Asked Questions

Find answers to common questions about our Audio Converter API to understand its full range of capabilities.

The primary reasons are compatibility and file size. For example, you might convert a large WAV file to a smaller MP3 for web streaming, or convert a modern FLAC file to a universally supported MP3 for older devices.

Yes. Simply provide a video file (like an MP4) as the input and set the output format to an audio format (like MP3). The API will automatically strip the video and give you just the audio track.

You can control quality primarily through the `audio_bitrate` parameter for lossy formats like MP3. A higher bitrate (e.g., "320k") results in better quality and a larger file, while a lower bitrate (e.g., "128k") results in a smaller file with lower quality.

MP3 is a "lossy" format, meaning it removes some sound data to create a smaller file, which is great for portability. FLAC is a "lossless" format, which means it preserves the original audio quality perfectly but results in a much larger file, ideal for archiving or audiophiles.

Yes, our API is designed to read and preserve common metadata tags (like ID3 tags) from the source file and embed them into the converted file.

Conversions are very fast, typically completing in just a few seconds. The exact time depends on the length and size of the source file, but our infrastructure is built for high-speed processing.

Absolutely. We use end-to-end TLS encryption for all data transfers. Your audio files are processed securely and are permanently deleted from our servers immediately after the job is complete.