Podcast to blog post with OpenAI and Ittybit

const EPISODE_URL = "https://podscribe-app.com/uploads/ep-47-raw.wav";

const res = await fetch("https://api.ittybit.com/jobs", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.ITTYBIT_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
kind: "audio",
input: EPISODE_URL,
options: {
format: "mp3",
quality: "high",
},
}),
});
const task = await res.json();

console.log(task.id); // "task_abc123"
console.log(task.status); // "queued"

import os
import requests

EPISODE_URL = "https://podscribe-app.com/uploads/ep-47-raw.wav"
ITTYBIT_API_KEY = os.environ["ITTYBIT_API_KEY"]

res = requests.post(
    "https://api.ittybit.com/jobs",
    headers={"Authorization": f"Bearer {ITTYBIT_API_KEY}"},
    json={
        "kind": "audio",
        "input": EPISODE_URL,
        "options": {
            "format": "mp3",
            "quality": "high",
        },
    },
)
task = res.json()

print(task["id"])     # "task_abc123"
print(task["status"]) # "queued"

async function waitForTask(taskId: string): Promise<any> {
  while (true) {
    const res = await fetch(`https://api.ittybit.com/jobs/${taskId}`, {
      headers: {
        Authorization: `Bearer ${process.env.ITTYBIT_API_KEY}`,
      },
    });
    const task = await res.json();

    if (task.status === "succeeded" || task.status === "failed") {
      return task;
    }

    await new Promise((r) => setTimeout(r, 2000));

}
}

const completed = await waitForTask(task.id);
const audioUrl = completed.output.url;

console.log(audioUrl);
// "https://cdn.ittybit.com/.../ep-47.mp3"

import time


def wait_for_task(task_id: str) -> dict:
    while True:
        res = requests.get(
            f"https://api.ittybit.com/jobs/{task_id}",
            headers={"Authorization": f"Bearer {ITTYBIT_API_KEY}"},
        )
        task = res.json()

        if task["status"] in ("succeeded", "failed"):
            return task

        time.sleep(2)


completed = wait_for_task(task["id"])
audio_url = completed["output"]["url"]

print(audio_url)
# "https://cdn.ittybit.com/.../ep-47.mp3"

import OpenAI from "openai";
import fs from "node:fs";

const openai = new OpenAI();

// Download the processed audio
const audio = await fetch(audioUrl);
const buffer = Buffer.from(await audio.arrayBuffer());
fs.writeFileSync("/tmp/episode.mp3", buffer);

const transcription = await openai.audio.transcriptions.create({
model: "whisper-1",
file: fs.createReadStream("/tmp/episode.mp3"),
response_format: "verbose_json",
});

console.log(`Transcribed ${transcription.segments?.length} segments`);
console.log(transcription.text.slice(0, 200));

from openai import OpenAI

client = OpenAI()

# Download the processed audio
audio = requests.get(audio_url)
with open("/tmp/episode.mp3", "wb") as f:
    f.write(audio.content)

with open("/tmp/episode.mp3", "rb") as f:
    transcription = client.audio.transcriptions.create(
        model="whisper-1",
        file=f,
        response_format="verbose_json",
    )

print(f"Transcribed {len(transcription.segments)} segments")
print(transcription.text[:200])

const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: [
    {
      role: "system",
      content: `You are a podcast editor. Given a transcript, produce:
1. A blog post (800-1200 words) that captures the key ideas in a readable narrative.
   Use markdown formatting with headings.
2. Show notes as a JSON object with fields: title, summary (2-3 sentences),
   topics (array of strings), and highlights (array of {time, description}).

Return your response as JSON with two keys: "blog_post" (markdown string)
and "show_notes" (object).`,
},
{
role: "user",
content: transcription.text,
},
],
response_format: { type: "json_object" },
});

const result = JSON.parse(response.choices[0].message.content!);

console.log("Blog post length:", result.blog_post.length);
console.log("Topics:", result.show_notes.topics);
console.log("Highlights:", result.show_notes.highlights.length);

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "system",
            "content": (
                "You are a podcast editor. Given a transcript, produce:\n"
                "1. A blog post (800-1200 words) that captures the key ideas in a readable narrative.\n"
                "   Use markdown formatting with headings.\n"
                "2. Show notes as a JSON object with fields: title, summary (2-3 sentences),\n"
                "   topics (array of strings), and highlights (array of {time, description}).\n\n"
                "Return your response as JSON with two keys: \"blog_post\" (markdown string) "
                "and \"show_notes\" (object)."
            ),
        },
        {
            "role": "user",
            "content": transcription.text,
        },
    ],
    response_format={"type": "json_object"},
)

import json

result = json.loads(response.choices[0].message.content)

print("Blog post length:", len(result["blog_post"]))
print("Topics:", result["show_notes"]["topics"])
print("Highlights:", len(result["show_notes"]["highlights"]))