How to Convert MP4 to MP3 in C# / .NET

MP4-to-MP3 in .NET is fundamentally an FFmpeg problem — there is no pure managed .NET audio transcoder that matches FFmpeg's codec support. Xabe.FFmpeg is the most popular .NET wrapper and provides a typed API over FFmpeg's command-line interface. For services where managing an FFmpeg binary is inconvenient, the ChangeThisFile API transcodes server-side via FFmpeg without any local binary.

Method 1: Xabe.FFmpeg (fluent .NET FFmpeg wrapper)

Xabe.FFmpeg wraps FFmpeg with a strongly-typed API. FFmpeg must be available on the PATH or at a configured directory — the library includes an optional auto-downloader.

dotnet add package Xabe.FFmpeg
dotnet add package Xabe.FFmpeg.Downloader  # optional: auto-download FFmpeg binaries

using Xabe.FFmpeg;
using Xabe.FFmpeg.Downloader;

public class Mp4ToMp3Service
{
    public Mp4ToMp3Service()
    {
        // Set FFmpeg binary path. If not on PATH, point to your install:
        // FFmpeg.SetExecutablesPath("/usr/local/bin");
    }

    /// <summary>Extract MP3 audio from an MP4 file.</summary>
    public async Task ConvertAsync(
        string inputPath,
        string outputPath,
        int bitrate = 192,
        CancellationToken ct = default)
    {
        var mediaInfo = await FFmpeg.GetMediaInfo(inputPath, ct);
        var audioStream = mediaInfo.AudioStreams.FirstOrDefault()
            ?? throw new InvalidOperationException(
                $"No audio stream found in {inputPath}");

        audioStream
            .SetCodec(AudioCodec.mp3)
            .SetBitrate(bitrate * 1000);  // Xabe expects bits/s

        await FFmpeg.Conversions.New()
            .AddStream(audioStream)
            .SetOutput(outputPath)
            .SetOverwriteOutput(true)
            .AddParameter("-q:a 2")  // VBR quality 2 = ~190kbps
            .Start(ct);
    }

    /// <summary>Download FFmpeg binaries if not already present.</summary>
    public static async Task EnsureFFmpegAsync(string ffmpegDir)
    {
        FFmpeg.SetExecutablesPath(ffmpegDir);
        await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official, ffmpegDir);
    }
}

// Usage
var service = new Mp4ToMp3Service();
await service.ConvertAsync("video.mp4", "audio.mp3", bitrate: 192);

Bitrate guide: 128kbps = speech/podcast quality, 192kbps = good music quality, 320kbps = maximum MP3 quality. VBR (-q:a 2) often gives better quality-per-byte than CBR at equivalent bitrate.

Method 2: ChangeThisFile API (HttpClient, no FFmpeg binary)

POST the MP4 with MultipartFormDataContent. The API runs FFmpeg server-side. Free tier: 1,000 conversions/month.

# Verify with curl first
curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer ctf_sk_your_key" \
  -F "file=@video.mp4" \
  -F "target=mp3" \
  --output audio.mp3

using System.Net.Http;
using System.Net.Http.Headers;

// Register in Program.cs:
// builder.Services.AddHttpClient("ctf", c =>
// {
//     c.BaseAddress = new Uri("https://changethisfile.com");
//     c.Timeout = TimeSpan.FromMinutes(5);
// });

public class AudioExtractService
{
    private readonly HttpClient _http;
    private const string ApiKey = "ctf_sk_your_key_here";

    public AudioExtractService(IHttpClientFactory factory)
        => _http = factory.CreateClient("ctf");

    public async Task<Stream> Mp4ToMp3Async(
        Stream mp4Stream,
        string fileName,
        CancellationToken ct = default)
    {
        using var form = new MultipartFormDataContent();

        var fileContent = new StreamContent(mp4Stream);
        fileContent.Headers.ContentType =
            new MediaTypeHeaderValue("video/mp4");
        form.Add(fileContent, "file", fileName);
        form.Add(new StringContent("mp3"), "target");

        using var request = new HttpRequestMessage(HttpMethod.Post, "/v1/convert")
        {
            Content = form,
            Headers = { Authorization =
                new AuthenticationHeaderValue("Bearer", ApiKey) }
        };

        // ResponseHeadersRead streams the response body without buffering
        var response = await _http.SendAsync(
            request, HttpCompletionOption.ResponseHeadersRead, ct);
        response.EnsureSuccessStatusCode();

        return await response.Content.ReadAsStreamAsync(ct);
    }
}

Using HttpCompletionOption.ResponseHeadersRead avoids buffering the entire MP3 in memory before writing — important for long audio files.

When to use each

Production tips

• Use IHttpClientFactory. Register a named "ctf" client in Program.cs with a 5-minute timeout (video transcoding can be slow). Never new HttpClient() inside a hot-path service method.
• Always check for an audio stream first. Some MP4 files are video-only (screen recordings, silent clips). Check mediaInfo.AudioStreams.Any() before starting conversion and return a clear error.
• Pass CancellationToken through. Xabe.FFmpeg's Start(ct) propagates cancellation to the underlying FFmpeg process. Wire it from HttpContext.RequestAborted in ASP.NET controllers.
• Stream the API response. Use HttpCompletionOption.ResponseHeadersRead and CopyToAsync rather than ReadAsByteArrayAsync for large files — avoids a full memory buffer.
• For batch jobs, limit concurrency. FFmpeg is CPU-intensive. Running 10 concurrent conversions on a 4-core server will saturate CPU. Use Parallel.ForEachAsync with a MaxDegreeOfParallelism equal to CPU count.
• Pre-check the file has audio. MP4 containers can hold video-only streams. Validate the stream count before queuing a conversion job to avoid wasted API calls.

For servers where FFmpeg is already present, Xabe.FFmpeg gives you fine-grained codec control with a clean .NET API. For containerized services or serverless functions, the ChangeThisFile API removes the FFmpeg dependency entirely. Free tier: 1,000 conversions/month.