So erstellst du deinen eigenen Podcast mit Hilfe von KI

Nutze den Azure OpenAI Service, um automatisch dein Podcast-Skript, die Beschreibung, Social-Media-Posts, das Audio und sogar das Cover zu generieren. Die englische Version dieses Beitrags findet ihr auf Medium.

Einführung

Ein Podcast ist ein digitales Audio- oder Videoformat, das sich mit ganz unterschiedlichen Themen beschäftigt – von Nachrichten über Storytelling und Interviews bis hin zu Bildung und Unterhaltung. Du findest Podcasts auf Plattformen wie Apple Podcasts, Spotify, Google Podcasts und vielen mehr – also jederzeit und überall abrufbar.

Podcasts sind heute ein beliebtes Medium, um Wissen zu teilen, Geschichten zu erzählen und Menschen zu erreichen. Und dank der Fortschritte im Bereich der künstlichen Intelligenz (KI) war es noch nie so einfach, effizient und zugänglich, selbst einen Podcast zu erstellen.

In diesem Blogpost zeige ich dir, wie du mit Hilfe von KI-Tools – darunter Azure OpenAI, Text-to-Speech (TTS) und der Bildgenerierung mit DALL·E 3 – ganz einfach deinen eigenen Podcast erstellen kannst.

Azure OpenAI Service für die Podcast-Erstellung nutzen

Der Azure OpenAI Service ist ein mächtiges Tool, um mithilfe von KI deinen eigenen Podcast zu erstellen. Er bietet dir verschiedene Modelle wie GPT-4.1, GPT-4.1-Mini sowie GPT-4o-Mini-TTS oder TTS (Text-to-Speech), mit denen du Inhalte generieren, Podcast-Skripte schreiben, Audiodateien erstellen und vieles mehr umsetzen kannst.

• GPT-4.1 Nano erstellt hochwertige Skripte für deinen Podcast
• GPT-4o-Mini-TTS wandelt deinen geschriebenen Text in natürlich klingendes, klares Audio um
• DALL·E 3 eignet sich perfekt, um ein Cover für deinen Podcast zu gestalten

Ein weiterer Vorteil: Azure OpenAI sorgt dafür, dass deine Daten sicher und privat bleiben. Prompts, Antworten, Embeddings und Trainingsdaten werden nicht mit anderen geteilt – deine Podcast-Ideen bleiben also ganz bei dir.

Die Podcastr-Anwendung

Einführung

Die Anwendung „Podcastr“ kombiniert verschiedene KI-Modelle und Logik, um die Podcast-Erstellung so einfach wie möglich zu machen. Sie automatisiert Aufgaben wie:

• Erstellen von Skript, Beschreibung und Social-Media-Posts für eine Podcast-Episode
• Generieren einer Audiodatei per Text-to-Speech (TTS)
• Gestalten eines Podcast-Covers mit DALL·E 3

Du gibst einfach die Eckdaten deiner Episode ein – den Rest übernimmt die App.

Podcastr unterstützt über 80 Sprachen und bietet verschiedene Stimmen. Diese sind zwar auf Englisch optimiert, sprechen aber auch viele andere Sprachen – perfekt, um ein internationales Publikum zu erreichen und hochwertige Übersetzungen zu liefern.

Außerdem kann Podcastr Inhalte direkt von einer Webseite (z. B. einem Medium-Post) abrufen und daraus ein Podcast-Skript erstellen. Mit Hilfe von Tools wie HttpClient und HtmlAgilityPack wird das HTML bereinigt, relevanter Text extrahiert und in ein strukturiertes Skript umgewandelt. Weitere Details dazu findest du in meinem vorherigen Blogpost.

Sobald du die Podcast-Details angibst – also Name, Sprache, Stimme und die URL der Quelle – holt sich die C#-Logik den Inhalt der Webseite. Danach übernehmen die drei KI-Modelle und erstellen daraus das Skript, das Audio und das passende Coverbild.

Der Code

Die Podcastr-Anwendung besteht aus mehreren Helferklassen, die den Prozess vereinfachen und die Funktionalität der Konsolen-App verbessern. Hier sind einige der wichtigsten Komponenten:

• ConsoleHelper: Diese Klasse kümmert sich um die ansprechende Gestaltung der Konsole und sorgt für ein benutzerfreundlicheres, interaktiveres Erlebnis.
• FileHelper: Diese Utility-Klasse speichert die generierten Dateien – also z. B. das Podcast-Audio und das Cover-Bild – in einem lokalen Ordner.
• WebsiteHelper: Diese Klasse ruft den HTML-Inhalt einer angegebenen URL ab. Mit Hilfe von HtmlAgilityPack wird das HTML bereinigt und überflüssiger Code entfernt, sodass nur der relevante Text für die Podcast-Erstellung übrig bleibt.

Die zentrale Logik der Anwendung steckt in der Klasse AzureOpenAIHelper. Hier findet die Kommunikation mit den Azure OpenAI Modellen statt. Diese Klasse koordiniert den Einsatz mehrerer KI-Modelle zur Erstellung von Podcast-Skript, Beschreibung und Social-Media-Posts.

Ein besonderes Feature ist der Einsatz von Structured Outputs. Anstatt einfache Textantworten zu erhalten, liefern die Modelle strukturierte JSON-Antworten. Das erleichtert die Weiterverarbeitung enorm – denn alle Infos für Skript, Beschreibung und Posts lassen sich gezielt und programmatisch auslesen. Wenn dich das Thema näher interessiert, schau dir gern meinen anderen englischen Beitrag dazu an, in dem ich tiefer darauf eingehe.

Die Methode GetPodcastContentAsync übernimmt die Erstellung von Skript, Beschreibung und Social-Posts in einem Rutsch. Sie nutzt dabei die Azure OpenAI Modelle und greift gezielt auf die Structured Outputs zurück.

/// <summary>
/// Retrieves podcast content based on the provided HTML input.
/// </summary>
/// <param name="chatClient">The Azure OpenAI chat client.</param>
/// <param name="htmlContent">The input HTML content.</param>
/// <param name="podcastName">The name of the podcast.</param>
/// <param name="podcastLanguage">The language of the podcast.</param>
/// <returns>A <see cref="PodcastContent"/> object containing script, 
/// description, and social posts; or null if deserialization fails.</returns>
/// <exception cref="AzureOpenAIException">Thrown when the request 
/// to OpenAI fails.</exception>
public static async Task<PodcastContent?> GetPodcastContentAsync(
    ChatClient chatClient,
    string? htmlContent,
    string podcastName,
    string podcastLanguage)
{
    try
    {
        ChatCompletionOptions options = new()
        {
            Temperature = 0.7f,
            ResponseFormat = ChatResponseFormat.CreateJsonSchemaFormat(
                "podcast_content",
                BinaryData.FromString(
                    /* language=JSON */
                    """
                    {
                      "type": "object",
                      "properties": {
                        "script": {
                          "type": "string",
                          "description": "The script of the podcast"
                        },
                        "description": {
                          "type": "string",
                          "description": "A brief description of the podcast"
                        },
                        "socialMediaPosts": {
                          "type": "object",
                          "properties": {
                            "linkedIn": { "type": "string" },
                            "twitter":  { "type": "string" },
                            "facebook": { "type": "string" },
                            "threads":  { "type": "string" }
                          },
                          "required": ["linkedIn", "twitter", "facebook", "threads"],
                          "additionalProperties": false
                        }
                      },
                      "required": ["script", "description", "socialMediaPosts"],
                      "additionalProperties": false
                    }
                    """))
        };

        SystemChatMessage systemChatMessage = 
                ChatMessage.CreateSystemMessage(
                    ChatMessageContentPart.CreateTextPart(
                        string.Format(
                            Statics.PodcastPrompt, 
                            podcastName, 
                            podcastLanguage, 
                            htmlContent)));

        ClientResult<ChatCompletion> chatResult = 
                await chatClient.CompleteChatAsync(
                    [systemChatMessage], options);

        ChatTokenUsage usage = chatResult.Value.Usage;
        TokenUsageHelper.AddChatInputTokenCount(usage.InputTokenCount);
        TokenUsageHelper.AddChatOutputTokenCount(usage.OutputTokenCount);

        using JsonDocument structuredJson = 
                JsonDocument.Parse(chatResult.Value.Content[0].Text);

        return JsonSerializer.Deserialize<PodcastContent>(
            structuredJson.RootElement.ToString(), _jsonSerializerOptions);
    }
    catch (Exception ex)
    {
        throw new AzureOpenAIException(
            "Error retrieving podcast content.", ex);
    }
}

Podcastr in Aktion

Hier siehst du die Konsolenanwendung in Aktion:

Zuerst gibst du eine Content-URL ein.

Danach gibst du den Namen deines Podcasts ein.

Gib nun die Sprache deines Podcasts an. Aktuell werden Deutsch, Englisch, Spanisch und Französisch direkt unterstützt – die KI-Modelle können aber auch mit vielen weiteren Sprachen umgehen.

Wähle eine Stimme aus. Azure OpenAI unterstützt verschiedene Stimmen.

Nachdem du alle Einstellungen konfiguriert hast, erstellt die Anwendung folgende Inhalte: Podcast-Skript, Podcast-Beschreibung, Social-Media-Posts zum Podcast, Podcast-Audio und Podcast-Cover.

Das Endergebnis ist ein ZIP-Archiv, das alle generierten Dateien enthält. Außerdem bekommst du eine ungefähre Preiskalkulation für die Erstellung angezeigt.

Here you can listen to the final podcast episode.

Fazit

Durch die Kombination mehrerer KI-Modelle – darunter GPT-4.1 für die Inhaltserstellung, GPT-4o Mini TTS für die Audiogenerierung und DALL·E 3 für die Bildgestaltung – wird die Podcast-Erstellung deutlich schneller und effizienter.

Die Anwendung Podcastr macht diesen Prozess extrem einfach und senkt die Einstiegshürden – Podcasting war noch nie so zugänglich. Mit KI sind den Möglichkeiten zur Inhaltserstellung kaum Grenzen gesetzt – die Zukunft des Podcastings sieht richtig vielversprechend aus.

Bereit, deinen eigenen Podcast mit KI zu erstellen? Dann schau im Podcastr GitHub-Repository vorbei, hol dir den Quellcode und starte noch heute in dein Podcast-Abenteuer!