Transkription mit Notion verbinden: API-Rezept (2026)

Die Arbeitsabläufe

Es gibt heute keine native Notion-Integration für ConvertAudioToText im Notion-Marktplatz. Was es gibt, ist ein sauberer API-Weg: Registriere einen Webhook-Endpunkt mit der CATT-API, empfange ein job.completed-Event, sobald ein Transkript fertig ist, hole das Transkript von der zurückgegebenen URL und schreibe es in eine Notion-Datenbank. Etwa 120 Zeilen Node.js, ein Nachmittag Einrichtung, und jede Aufnahme deines Teams wird zu durchsuchbarem Notion-Content.

Drei Muster decken die meisten Team-Setups ab. Dieser Leitfaden geht das Datenbank-Zeilen-Muster vollständig durch, mit Hinweisen zu den anderen.

Datenbank-Zeile pro Transkript. Eine „Transcripts“-Datenbank mit Spalten für Datum, Sprecher, Projekt, Zusammenfassung und einem Link zum Ergebnis. Am besten für Teams, die über viele Aufnahmen hinweg filtern und sortieren.

An bestehende Projektseiten angehängt. Jedes Transkript hängt Blöcke an eine bestehende Projekt- oder Meeting-Seite an. Am besten für Teams, bei denen Transkripte innerhalb umfassenderer Projektnotizen liegen.

Eine Seite pro Sprecher oder Interviewpartner. Pflege eine Zuordnung von Sprecher zu Seiten-ID und leite Transkripte entsprechend weiter. Nützlich für Journalisten mit wiederkehrenden Quellen und Vertriebsteams, die Schlüsselkonten verfolgen.

Schritt 1: Die Notion-Datenbank erstellen

Erstelle in Notion eine neue Vollseiten-Datenbank mit diesen Eigenschaften:

Kopiere die Datenbank-ID aus der URL. Es ist die 32-stellige Hex-Zeichenfolge, die auf den letzten Schrägstrich folgt und vor jedem ?v=-Abfrageparameter steht.

Schritt 2: Eine Notion-Integration erstellen

1. Gehen Sie zu notion.so/my-integrations und klicken Sie auf „Neue Integration".
2. Benennen Sie sie (zum Beispiel „Transkriptions-Integration"), wählen Sie Ihren Workspace, den Typ „Intern" und bestätigen Sie.
3. Kopieren Sie das Interne Integrations-Token. Seit September 2024 beginnen neue Tokens mit ntn_ statt mit dem älteren Präfix secret_. Beide Formate funktionieren in API-Aufrufen identisch.
4. Öffnen Sie Ihre Transkript-Datenbank in Notion, klicken Sie auf das „..."-Menü, gehen Sie zu „Verbindungen hinzufügen" und wählen Sie Ihre Integration.

Die Integration hat nur Zugriff auf Datenbanken, die Sie ihr explizit freigeben.

Schritt 3: Einen Webhook bei CATT registrieren

Webhooks bei ConvertAudioToText erfordern den Business-Plan. Registrieren Sie Ihren Endpoint:

curl -X POST https://api.convertaudiototext.com/api/v1/webhooks \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-server.com/webhooks/catt",
    "events": ["job.completed", "job.failed"]
  }'

Die Antwort enthält ein secret-Feld. Speichern Sie es als CATT_WEBHOOK_SECRET in Ihrer Umgebung. Sie können diesen Wert nach der Erstellung nicht erneut abrufen.

Für die Polling-Alternative (ohne Webhook) siehe Webhook vs. Polling für Transkripte.

Schritt 4: Der Webhook-Handler

Das job.completed-Payload enthält ein result_url-Feld, das auf das vollständige Transkript verweist. Der Handler prüft die Signatur, kontrolliert den Ereignistyp, ruft das Transkript ab und schreibt es dann in Notion.

import express from 'express';
import { Client as NotionClient } from '@notionhq/client';
import crypto from 'crypto';

const app = express();
const notion = new NotionClient({ auth: process.env.NOTION_TOKEN });
const NOTION_DB_ID = process.env.NOTION_DATABASE_ID;

app.post(
  '/webhooks/catt',
  express.raw({ type: 'application/json' }),
  async (req, res) => {
    const sigHeader = req.header('X-Webhook-Signature'); // "sha256=<hex>"
    const [, sig] = (sigHeader || '').split('=');
    const expected = crypto
      .createHmac('sha256', process.env.CATT_WEBHOOK_SECRET)
      .update(req.body)
      .digest('hex');

    if (!sig || !crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected))) {
      return res.status(401).send('Bad signature');
    }

    const event = JSON.parse(req.body.toString());
    if (event.event !== 'job.completed') return res.sendStatus(200);

    // Vollständiges Transkript von der Ergebnis-URL abrufen
    const result = await fetch(event.data.result_url, {
      headers: { Authorization: `Bearer ${process.env.CATT_API_KEY}` }
    }).then(r => r.json());

    await createNotionPage({
      jobId: event.data.job_id,
      language: event.data.language,
      durationSeconds: event.data.duration,
      completedAt: event.data.completed_at,
      resultUrl: event.data.result_url,
      transcript: result.transcript,
      summary: result.summary,
      utterances: result.utterances,
      filename: result.filename,
    });

    res.sendStatus(200);
  }
);

Die Event-Felder, die bei job.completed immer vorhanden sind: event, timestamp, data.job_id, data.status, data.created_at, data.language, data.duration, data.completed_at, data.result_url. Der vollständige Transkripttext, die Zusammenfassung und die Utterances stammen aus dem Ergebnisabruf, nicht aus dem Event selbst.

Zusammenfassung plus Transkript: die zwei Blöcke, die deine Notion-Datenbank will

Schritt 5: Die Notion-Seite schreiben

async function createNotionPage(data) {
  const transcriptBlocks = buildTranscriptBlocks(data.utterances || []);

const page = await notion.pages.create({
    parent: { database_id: NOTION_DB_ID },
    properties: {
      Title: {
        title: [{ text: { content: data.filename || `Transcript ${data.completedAt?.slice(0, 10)}` } }]
      },
      Date: { date: { start: data.completedAt?.slice(0, 10) || new Date().toISOString().slice(0, 10) } },
      Language: { select: { name: data.language || 'auto' } },
      Duration: { number: data.durationSeconds },
      'Result URL': { url: data.resultUrl },
      Summary: {
        rich_text: [{ text: { content: (data.summary || '').slice(0, 2000) } }]
      }
    }
  });

  // Transkriptblöcke in Batches von 100 anhängen (Notion-API-Limit)
  if (transcriptBlocks.length > 0) {
    await appendBlocksInBatches(page.id, transcriptBlocks);
  }
}

function buildTranscriptBlocks(utterances) {
  const blocks = [];

  blocks.push({
    object: 'block',
    type: 'heading_2',
    heading_2: { rich_text: [{ text: { content: 'Transcript' } }] }
  });

  for (const u of utterances) {
    // Notion rich_text.content ist auf 2.000 Zeichen pro Block begrenzt
    const label = u.speaker ? `[${u.speaker}] ` : '';
    const text = (label + (u.text || '')).slice(0, 2000);
    blocks.push({
      object: 'block',
      type: 'paragraph',
      paragraph: { rich_text: [{ text: { content: text } }] }
    });
  }

  return blocks;
}

async function appendBlocksInBatches(pageId, blocks) {
  for (let i = 0; i < blocks.length; i += 100) {
    const batch = blocks.slice(i, i + 100);
    await notion.blocks.children.append({ block_id: pageId, children: batch });
    if (i + 100 < blocks.length) {
      await new Promise(r => setTimeout(r, 400)); // innerhalb des Durchschnitts von 3 req/s bleiben
    }
  }
}

Das Limit von 100 Blöcken pro Anfrage ist eine harte Einschränkung der Notion-API. Die 400ms Pause hält dich im Durchschnitt unter 3 Anfragen pro Sekunde. Bei sehr langen Aufnahmen (100+ Äußerungen) dauert das Schreiben ein paar Sekunden; das ist für einen asynchronen Nachbearbeitungsschritt akzeptabel.

Variation: Append to an Existing Project Page

Wenn Transkripte in Projektseiten statt in einer eigenständigen Datenbank gehören, verwende blocks.children.append mit einer vorhandenen Seiten-ID:

async function appendToProjectPage(projectPageId, data) {
  const divider = { object: 'block', type: 'divider', divider: {} };
  const heading = {
    object: 'block',
    type: 'heading_3',
    heading_3: {
      rich_text: [{ text: { content: `Meeting transcript ${data.completedAt?.slice(0, 10)}` } }]
    }
  };
  const transcriptBlocks = buildTranscriptBlocks(data.utterances || []);
  await appendBlocksInBatches(projectPageId, [divider, heading, ...transcriptBlocks]);
}

No-Code-Pfade

Wenn du das ohne eigenen Server umsetzen willst, gibt es heute zwei Optionen.

Zapier. Der Ablauf: Webhook-Trigger (fängt das CATT job.completed-Event ab), dann ein Code-Schritt zum Abrufen der Ergebnis-URL, danach eine Aktion "Create Database Item" in Notion. Mehrstufige Zaps erfordern einen kostenpflichtigen Zapier-Plan. Zapier ist schneller eingerichtet als eigener Code, aber schwieriger zu debuggen, wenn Notion-Schreibvorgänge stillschweigend fehlschlagen.

n8n. Es gibt eine veröffentlichte n8n-Workflow-Vorlage, die Whisper-Transkription mit einer Notion-Seite verknüpft. Die selbst gehostete Version von n8n ist kostenlos mit unbegrenzten Ausführungen und hält Aufnahmen aus vendor-eigenen Clouds heraus. Make.com hat ebenfalls ein Notion-Modul, das genauso funktioniert. Siehe Transkription mit Zapier automatisieren für eine Schritt-für-Schritt-No-Code-Anleitung.

Fireflies.ai hat eine native Notion-Integration (kein Zapier nötig), die Meeting-Zusammenfassungen, Aktionspunkte und einen Transkript-Link nach jedem aufgezeichneten Anruf in eine Notion-Datenbank pusht. Das ist die richtige Wahl, wenn du hauptsächlich Meeting-Bots statt Datei-Uploads brauchst.

Notion-API-Versionshinweis (2026)

Die Notion-API-Version 2026-03-11 hat drei bahnbrechende Änderungen eingeführt, die du kennen solltest, wenn du bestehende Integrationen aktualisierst:

• Der Parameter after in append-block-children wird durch position ersetzt.
• Das Feld archived wird durch in_trash ersetzt.
• Der Blocktyp transcription wird in meeting_notes umbenannt.

Wenn Sie heute neuen Code schreiben, installieren Sie @notionhq/client in Version 5.12.0 oder höher und setzen Sie notionVersion: "2026-03-11" beim Erstellen des Clients, wenn Sie das neueste Verhalten wünschen. Ältere Token-Formate (Präfix secret_) funktionieren weiterhin.

Produktionsmuster

Journalismus-Teams. Jedes aufgenommene Interview landet in einer durchsuchbaren Notion-Datenbank. Eigenschaftsfilter nach Thema, Quelle und Datum ermöglichen es Reportern, in Sekunden alle Zitate einer Quelle abzurufen. Für den gesamten Interview-Workflow siehe So transkribieren Sie eine Interviewaufnahme.

Customer-Success-Teams. Jeder Kundentermin landet auf einer pro Kunden angelegten Notion-Seite. Die Vorbereitung des vierteljährlichen Geschäftsreviews sinkt von Stunden des erneuten Anhörens auf 15 Minuten Lesen.

Podcast-Produktion. Jede Episode erhält eine Notion-Seite mit Transkript, Zusammenfassung und der Ergebnis-URL für die Bearbeitung. Der Produzent übergibt an das Social-Media-Team, ohne die rohe Audiodatei zu teilen. Siehe beste Transkription für Podcasts für Genauigkeitsvergleiche gängiger Tools.

Wenn Sie nur ein sauberes Transkript ohne Webhook-Server benötigen, übernimmt ConvertAudioToText den Upload und erzeugt eine sprechergekennzeichnete Ausgabe, die Sie kopieren und direkt in jede Notion-Seite einfügen können.

Für die Erstellung der Besprechungsprotokoll-Ebene auf Basis des rohen Transkripts behandelt Besprechungsprotokolle aus Audio erstellen die strukturierten Ausgabemuster, die sauber auf Notion-Datenbankeigenschaften abbilden.

FAQ

Hat ConvertAudioToText eine native Notion-Integration?

Noch nicht. Es gibt keine Ein-Klick-Verbindung im Notion-Integrationsmarktplatz. Der funktionierende Weg ist, einen Webhook-Endpunkt zu registrieren (Business-Plan), der ein job.completed-Event empfängt, dann das Transkript über die result_url abruft und es über die Notion API in Notion schreibt.

Welche Notion API-Limits sollte ich einplanen?

Die Notion API erlaubt durchschnittlich 3 Anfragen pro Sekunde und Integration. Jeder append-block-children-Aufruf akzeptiert maximal 100 Blöcke. Rich-Text-Inhalt pro Block ist auf 2.000 Zeichen begrenzt. Bei langen Transkripten solltest du deine Block-Appends in Stapeln von 100 mit einer kurzen Verzögerung zwischen den Aufrufen ausführen.

Brauche ich einen kostenpflichtigen Notion-Plan für die API?

Nein. Die Notion API ist auf allen Notion-Plänen kostenlos, auch im kostenlosen Tarif. Einen kostenpflichtigen Plan brauchst du nur für Notion-Funktionen wie das Teilen mit Gästen über bestimmte Grenzen hinaus. Die API-Ratenlimits sind auf allen Plänen gleich.

Was ist der No-Code-Weg, um Transkripte an Notion zu senden?

Zwei gute Optionen: Zapier (kostenpflichtiger Tarif für mehrstufige Zaps) lässt dich einen Webhook abfangen und eine Notion-Seite ohne Code erstellen. n8n Cloud hat eine Whisper-to-Notion-Vorlage, und die selbst gehostete Version läuft kostenlos. Beide Wege eignen sich für einfache Transkript-zu-Seite-Abläufe; benutzerdefinierter Code ist besser für sprechermarkierte Blöcke, Stapelverarbeitung und lange Dateien.

Quellen

• Notion API: Anforderungslimits - geprüft am 02.07.2026
• Notion API: Block-Kinder anhängen - geprüft am 02.07.2026
• Notion API-Upgrade-Leitfaden vom 11.03.2026 - geprüft am 02.07.2026
• Fireflies Notion-Integrationsleitfaden - geprüft am 02.07.2026
• Notion-Integrationsmarktplatz - geprüft am 02.07.2026 (keine nativen Transkriptions-Connectors gelistet)
• @notionhq/client auf npm - v5.12.0 unterstützt API-Version 2026-03-11