Podcast show notes, chapters and social clips generation

Creating podcast content used to mean wearing multiple hats: recording the episode, manually transcribing it, cutting clips from the audio file, writing show notes, generating chapter markers, and then distributing short-form clips across social media. Each step required a different tool and a person actually moving files and data between them. The friction was real, and it ate up hours each week. For more on this, see Social media content calendar from blog posts and news feeds.

The good news is that this entire pipeline can now run on its own. Once you set it up, your podcast infrastructure becomes almost invisible. You record an episode, upload it somewhere, and three hours later you have polished show notes, timestamped chapters, multiple social media clips, and a summary ready to email to your subscribers. No manual handoff between tools. No copy-pasting transcripts. No manually deciding where to cut clips.

This workflow combines three specialist tools (Clipwing for audio clip generation, MeetGeek for transcription and summarisation, and Resoomer for intelligent text condensing) with an orchestration layer that wires them together. We'll walk through how to build it, which orchestration tool works best, and the specific API calls that make it all happen.

The Automated Workflow

What happens when you press go

When you upload a new podcast episode to your chosen storage location (Google Drive, Dropbox, or an S3 bucket), the orchestration tool detects it immediately. It then sends the audio file to MeetGeek, which transcribes it and extracts key points. While that's happening, Clipwing processes the same audio to identify and cut natural speaking breaks into short, punchy social clips. Resoomer then condenses the transcript into a structured summary. Finally, all this data flows into a formatted document that lands in your email inbox. The entire sequence takes roughly 2–3 hours depending on episode length.

Choosing your orchestration tool

For this workflow, we recommend Make (Integromat) for beginners. It has native integrations with all three tools, a visual builder that doesn't require coding, and generous free-tier credits (around 1000 operations per month). If you want more control and don't mind writing a bit of code, n8n is self-hosted and has no monthly limits. Zapier works but lacks direct Clipwing integration, so you'd need intermediate HTTP requests. Claude Code is less suitable here because it's designed for ad-hoc analysis rather than scheduled, recurring automation.

Step 1: Detect the new podcast file

Your workflow starts with a trigger. In Make, you'll use either the Google Drive watch trigger or the Dropbox watch trigger, depending on where you store your files. Here's what the trigger configuration looks like:

Copy
{
  "trigger": "google_drive.watch_folder",
  "folder_id": "YOUR_FOLDER_ID",
  "file_filter": {
    "mime_type": "audio/mpeg",
    "name_pattern": "*.mp3"
  },
  "polling_interval": 300
}

Set the polling interval to 300 seconds (5 minutes) to keep API costs reasonable while still catching new files quickly. Make will now monitor your folder and fire the rest of your workflow whenever a new MP3 appears.

Step 2: Send audio to MeetGeek for transcription

MeetGeek handles transcription, speaker identification, and automatic point extraction. You'll need a MeetGeek API key; grab it from their dashboard under settings.

The API call looks like this:

Copy
[POST](/tools/post) https://api.meetgeek.ai/v1/transcribe
Content-Type: application/json
Authorization: Bearer YOUR_MEETGEEK_API_KEY

{
  "source_url": "https://your-storage-url/episode.mp3",
  "title": "Podcast Episode Title",
  "language": "en",
  "extract_key_points": true,
  "speaker_detection": true,
  "output_format": "json"
}

MeetGeek will return a transcript with timings, identified speakers, and extracted key points. Store the transcript text and the key points array for use in later steps. The full response typically includes:

Copy{
  "transcript_id": "trans_abc123",
  "status": "completed",
  "transcript": [
    {
      "speaker": "Host",
      "text": "Welcome to the show...",
      "timestamp": "00:00:15"
    },
    {
      "speaker": "Guest",
      "text": "Thanks for having me...",
      "timestamp": "00:00:32"
    }
  ],
  "key_points": [
    "Topic 1 discussed",
    "Key insight from guest",
    "Action item mentioned"
  ]
}

Step 3: Generate social clips with Clipwing

Clipwing automatically detects interesting segments in your audio and cuts them into short clips suitable for social media. Its API accepts the same audio file and returns a list of cut points.

Copy
POST https://api.clipwing.com/v1/generate_clips
Content-Type: application/json
X-API-Key: YOUR_CLIPWING_API_KEY

{
  "audio_url": "https://your-storage-url/episode.mp3",
  "target_duration": 60,
  "max_clips": 5,
  "silence_threshold": -40,
  "min_clip_length": 30,
  "format": "vertical"
}

Clipwing responds with clip metadata including start and end times, suggested captions, and a download URL for each clip:

Copy{
  "clips": [
    {
      "clip_id": "clip_001",
      "start_time": 342,
      "end_time": 408,
      "duration": 66,
      "confidence": 0.92,
      "suggested_caption": "On why consistency matters",
      "download_url": "https://clipwing-cdn.com/clip_001.mp4"
    }
  ]
}

Store these URLs and captions for distribution later.

Step 4: Summarise the transcript with Resoomer

Resoomer takes the full transcript from MeetGeek and creates a condensed summary. This becomes your show notes or email summary.

Copy
POST https://api.resoomer.com/v1/summarize
Content-Type: application/json
Authorization: Bearer YOUR_RESOOMER_API_KEY

{
  "text": "Full transcript text from MeetGeek...",
  "compression_rate": 30,
  "language": "en",
  "output_type": "bullets"
}

Resoomer returns a bulleted summary, typically reducing 4000 words down to 1200 words:

Copy{
  "summary": [
    "- Host introduces topic of workflow automation",
    "- Guest explains benefits of orchestration tools",
    "- Discussion of cost savings achieved by clients",
    "- Q&A segment covering common misconceptions"
  ],
  "compression_ratio": 0.31,
  "keywords": ["automation", "workflow", "orchestration"]
}

Step 5: Build chapter markers from timestamps

This step doesn't require an external API. Use Make's built-in text processing to parse the MeetGeek transcript and identify natural chapter breaks. Look for key points that have significant time gaps between them. Format these as chapters:

Copy
00:00:00 - Introduction
05:32:00 - Guest background
18:47:00 - Main topic discussion
34:15:00 - Case study walkthrough
42:09:00 - Q&A session

Store this as plain text or in a format that podcast hosting platforms accept (most support simple timestamp-separated chapter formats).

Step 6: Compile and distribute

In the final step, Make formats all the data you've gathered: the summary from Resoomer, the chapters you built, the clip links from Clipwing, and the key points from MeetGeek. You have several distribution options:

Send everything to a Google Doc template that automatically formats the show notes:

Copy
POST https://[docs](/tools/docs).googleapis.com/v1/documents/{DOCUMENT_ID}:batchUpdate
Authorization: Bearer YOUR_GOOGLE_API_KEY

{
  "requests": [
    {
      "insertText": {
        "text": "Episode Title",
        "location": {"index": 1}
      }
    },
    {
      "insertText": {
        "text": "Summary goes here...",
        "location": {"index": 50}
      }
    }
  ]
}

Or send an email with all the information formatted nicely:

Copy
TO: your-email@example.com
SUBJECT: Show Notes: [Episode Title]

SUMMARY:
[Resoomer summary here]

CHAPTERS:
[Timestamped chapters here]

SOCIAL CLIPS:
[Links and captions here]

KEY POINTS:
[Extracted points from MeetGeek here]

Making it work in Make (Integromat)

Here's the rough sequence of modules you'll create:

1. Google Drive / Dropbox trigger (watches for new audio files)
2. HTTP module calling MeetGeek API
3. HTTP module calling Clipwing API
4. HTTP module calling Resoomer API
5. Text processing module (to build chapters from transcript timestamps)
6. Google Docs or Gmail module (to distribute results)

In Make's visual editor, each module connects via mapping. The output of MeetGeek (the transcript) becomes the input to Resoomer. The audio file URL becomes input to Clipwing. Make handles all the data passing for you.

The Manual Alternative

If you're uncomfortable with automation or want more creative control, you can still save significant time by running these tools individually in sequence. Record your episode, download the MP3, manually upload it to MeetGeek for transcription, then use Resoomer's web interface to summarise the transcript, and Clipwing's web UI to generate clips. This approach takes roughly 45 minutes per episode instead of 10 minutes with full automation. It's more hands-on but lets you review and adjust summaries or clip selections before they're published. Some podcasters prefer this hybrid approach, keeping orchestration only for the most repetitive parts (like clip distribution) while handling transcription review manually.......

Pro Tips

Monitor API rate limits carefully. MeetGeek allows 100 transcriptions per month on the free tier; Clipwing allows 50 clip generations. If your podcast runs weekly, you'll exceed free limits within a month. Budget for paid tiers, or stagger processing across multiple accounts (though that violates most terms of service, so don't do this).

Build in error handling for long episodes. Audio files over 90 minutes can timeout with some APIs. In Make, add a conditional step that checks audio duration and splits files longer than 90 minutes into chunks, processing each separately, then recombining results. This adds complexity but prevents failed workflows.

Use a content calendar to schedule uploads. Rather than uploading files as soon as they're ready, upload them to a specific folder on a schedule. This spreads API calls evenly and prevents you hitting rate limits on days when multiple episodes drop.

Store all outputs in a shared drive. Have Make save the generated show notes, clips, and chapters to a shared Google Drive folder that your social media manager can access. This creates a paper trail and lets multiple people review before publishing.

Test the workflow with a dummy file first. Before your first real episode flows through, use a test audio file (even a 5-minute sample) to verify each step works and you're getting the outputs you expect. This catches configuration errors before they affect your actual content.

Watch for transcript errors. Automated transcription services sometimes misheard technical terms or speaker names. Add a manual review step where you skim the transcript quickly for obvious errors before it's used for summaries and chapters. This takes 3-5 minutes and prevents embarrassing mistakes in your show notes.

Cost Breakdown

If you publish more than one episode per week, expect to pay $120–150 monthly for the necessary paid tiers across all tools. If you publish less frequently (fortnightly), you can stay within free tiers and pay only for Make's Pro tier ($10–15), bringing monthly cost down to $25–30.