How to Automate Podcast Editing with an API

If you publish a podcast regularly, you know the routine: record, upload, wait for editing, download, publish. Multiply that by four episodes a month and you’re spending hours on repetitive file management. What if your recording software could hand off the raw audio to an editing service automatically?

That’s exactly what the Barevalue API does. It lets you submit raw podcast recordings programmatically and get back fully edited episodes — with filler words removed, noise reduced, volume normalized, and show notes generated — without ever opening a browser.

In this guide, we’ll walk through how to automate your entire podcast post-production pipeline using the Barevalue REST API, webhooks, and our MCP server for AI assistant integration.

What You Get From the API

The Barevalue API gives you programmatic access to the same AI editing pipeline that powers the web interface. Every API order includes:

• Full audio processing — noise reduction, volume normalization, filler word removal (ums, ahs), silence trimming
• Multi-track mixing — upload separate host and guest tracks, we mix them
• Transcription — full episode transcript
• AI show notes — summary, highlights, and key takeaways
• Social media clips — AI-selected highlight clips for promotion
• Webhook notifications — get notified the moment your episode is ready

Getting Started: Authentication

First, you’ll need an API key. Create a free Barevalue account (every account includes bonus minutes to test with — no credit card required), navigate to Settings → API Keys, and generate a key.

All API requests use Bearer token authentication:

curl -H "Authorization: Bearer bv_sk_your_api_key_here" \
  https://barevalue.com/api/v1/account

This returns your account info, subscription minutes remaining, and pricing — everything you need to know before submitting an order.

The Three-Step Workflow

Submitting a podcast for editing takes three API calls:

Step 1: Get a Presigned Upload URL

curl -X POST https://barevalue.com/api/v1/orders/upload-url \
  -H "Authorization: Bearer bv_sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{"filename": "episode-42.mp3", "content_type": "audio/mpeg"}'

This returns a presigned S3 URL that’s valid for one hour. No need to manage AWS credentials — the API handles it.

Step 2: Upload Your Audio

curl -X PUT \
  -H "Content-Type: audio/mpeg" \
  --data-binary @episode-42.mp3 \
  "https://barevalue-files.s3.amazonaws.com/..."

Upload directly to S3 using the presigned URL. This works with files up to 750MB.

Step 3: Submit the Order

curl -X POST https://barevalue.com/api/v1/orders/submit \
  -H "Authorization: Bearer bv_sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "s3_key": "413/16000/raw/episode-42.mp3",
    "podcast_name": "The Dev Show",
    "episode_name": "Episode 42: API Automation"
  }'

That’s it. The AI pipeline picks up your order, processes it, and delivers the results. Typical turnaround is under 30 minutes for episodes up to an hour.

Multi-Track Support

Recording with separate microphones for host and guest? The API handles multi-track uploads natively:

curl -X POST https://barevalue.com/api/v1/orders/upload-urls \
  -H "Authorization: Bearer bv_sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "files": [
      {"filename": "host.mp3", "content_type": "audio/mpeg", "size_bytes": 45000000, "role": "host"},
      {"filename": "guest.mp3", "content_type": "audio/mpeg", "size_bytes": 43000000, "role": "guest"},
      {"filename": "intro.mp3", "content_type": "audio/mpeg", "size_bytes": 2000000, "role": "intro"}
    ]
  }'

Each track gets its own upload URL. After uploading all files, submit the order using the returned order_id. The AI handles mixing, level matching between speakers, and all post-production.

Submit by URL (No Upload Needed)

Already have your audio hosted somewhere? Skip the upload entirely:

curl -X POST https://barevalue.com/api/v1/orders/submit-url \
  -H "Authorization: Bearer bv_sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-server.com/recordings/episode-42.mp3",
    "podcast_name": "The Dev Show",
    "episode_name": "Episode 42"
  }'

The API downloads the file and processes it. This is particularly useful if you record to a cloud service or have a recording bot that saves to a server.

Webhooks: Get Notified When It’s Done

Instead of polling for order status, register a webhook and we’ll POST to your endpoint when the order completes:

curl -X POST https://barevalue.com/api/v1/webhooks \
  -H "Authorization: Bearer bv_sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-server.com/webhook/barevalue",
    "events": ["order.completed", "order.failed"],
    "secret": "your_webhook_secret"
  }'

When an order completes, you receive a signed POST with the order details and download links. Verify the signature using your webhook secret, download the files, and publish — all without human intervention.

Real-World Automation: A Complete Pipeline

Here’s what a fully automated podcast pipeline looks like in Python:

import requests
import os

API_KEY = os.environ["BAREVALUE_API_KEY"]
BASE = "https://barevalue.com/api/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}

def process_episode(audio_path, podcast_name, episode_name):
    # 1. Get upload URL
    resp = requests.post(f"{BASE}/orders/upload-url", headers=HEADERS, json={
        "filename": os.path.basename(audio_path),
        "content_type": "audio/mpeg"
    })
    upload_info = resp.json()

    # 2. Upload the file
    with open(audio_path, "rb") as f:
        requests.put(
            upload_info["upload_url"],
            headers={"Content-Type": "audio/mpeg"},
            data=f
        )

    # 3. Submit the order
    resp = requests.post(f"{BASE}/orders/submit", headers=HEADERS, json={
        "s3_key": upload_info["s3_key"],
        "podcast_name": podcast_name,
        "episode_name": episode_name
    })

    order = resp.json()
    print(f"Order {order['order_id']} submitted. Status: {order['state']}")
    return order

# Process an episode
process_episode("raw-episode-42.mp3", "The Dev Show", "Episode 42")

Pair this with a webhook handler and you have a zero-touch pipeline: record → upload → edited episode lands in your publishing queue.

MCP Server: Use Barevalue From Claude Code

If you use Claude Code or another AI coding assistant that supports the Model Context Protocol (MCP), you can submit and manage podcast orders directly from your IDE.

Quick Setup (2 minutes)

Add Barevalue to your Claude Code configuration:

# In your Claude Code settings, add this MCP server:
{
  "mcpServers": {
    "barevalue": {
      "command": "npx",
      "args": ["-y", "barevalue-mcp"],
      "env": {
        "BAREVALUE_API_KEY": "bv_sk_your_api_key_here"
      }
    }
  }
}

That’s it. Restart Claude Code and you can now talk to it naturally:

• “Submit episode-42.mp3 for editing” — uploads and submits the file
• “Check the status of my orders” — lists recent orders with their state
• “How many minutes do I have left?” — shows your subscription balance
• “Set up a webhook at https://my-server.com/hook” — registers a completion webhook

The MCP server exposes 12 tools that map to all API endpoints — account info, file upload, order submission, status checks, webhook management, and API key rotation. View the full tool reference on GitHub.

Pricing

API orders use your existing subscription minutes — no separate API pricing. Every new account includes bonus minutes to test the full pipeline. Check our pricing page for current plans and rates.

Getting Started

Ready to automate your podcast editing?

1. Create a free account — bonus minutes included, no credit card required
2. Generate an API key from Settings → API Keys
3. Submit your first order using the curl examples above
4. Register a webhook for completion notifications
5. Optionally, install the MCP server for Claude Code integration

Full API documentation is available in your account dashboard after signup.

Questions? Reach us at support@barevalue.com.