n8nworkflows.xyz/workflows/Send YouTube transcripts to Slack using AssemblyAI-12935/readme-12935.md

Send YouTube transcripts to Slack using AssemblyAI

https://n8nworkflows.xyz/workflows/send-youtube-transcripts-to-slack-using-assemblyai-12935


# Send YouTube transcripts to Slack using AssemblyAI

## 1. Workflow Overview

**Title:** Send YouTube transcripts to Slack using AssemblyAI  
**Workflow name (in JSON):** `rippr – YouTube Transcript`

**Purpose:**  
This workflow lets a Slack user submit a YouTube link via a Slack slash command. The workflow extracts the YouTube video ID, checks the video duration (enforcing a max length), converts the video to MP3 via RapidAPI, uploads the audio to AssemblyAI, polls until transcription is complete, then cleans the transcript using OpenAI and posts the final formatted text back into Slack via Slack’s `response_url`.

**Typical use cases:**
- Quickly “rip” a transcript from a YouTube link without leaving Slack.
- Enforce short video limits to control cost/time.
- Produce a readable transcript (cleaned formatting) for sharing in a channel.

### 1.1 Input Reception (Slack)
Receives Slack slash-command payload and normalizes key fields.

### 1.2 YouTube URL Parsing + Duration Guardrail
Extracts the YouTube video ID from the Slack text, calls YouTube Data API (via RapidAPI) to get duration, and blocks videos longer than a configured threshold (10 minutes).

### 1.3 Audio Conversion + AssemblyAI Job Creation
Downloads MP3 audio (RapidAPI), uploads to AssemblyAI, and creates a transcription job.

### 1.4 Polling for Completion + Transcript Retrieval
Waits and repeatedly checks AssemblyAI job status until it is completed, then extracts the transcript text.

### 1.5 Cleanup (OpenAI) + Slack Delivery
Uses OpenAI to reformat transcript for readability (not a summary despite the node name), then posts the result back to Slack.

---

## 2. Block-by-Block Analysis

### Block 1 — Slack Command Intake & Normalization
**Overview:**  
Accepts a Slack slash command request, immediately responds with an “in progress” message, and prepares the payload for downstream nodes.

**Nodes involved:**
- `Receive Slack command`
- `Normalize Slack payload`

#### Node: Receive Slack command
- **Type / role:** Webhook trigger; entrypoint for Slack slash command.
- **Configuration choices:**
  - **HTTP Method:** POST
  - **Path:** `rippr` (Slack slash command should POST to this endpoint)
  - **Immediate response message:** `🗡️ Ripping the full transcript… wait a few minutes, I’ll post it here soon (• v •)`
  - **Response mode:** configured via webhook `options.responseData` (static text)
- **Inputs/Outputs:**
  - **Input:** Slack payload in `body` (typical Slack slash command fields like `text`, `response_url`, etc.)
  - **Output:** Passes request data to `Normalize Slack payload`
- **Failure/edge cases:**
  - Slack may retry if webhook does not respond quickly; ensure n8n is reachable and the webhook responds immediately (this node does).
  - If Slack signing/verification is required, it is **not implemented** here (no signature validation).

#### Node: Normalize Slack payload
- **Type / role:** Set node; maps/creates a `videoUrl` field from Slack’s request body.
- **Configuration choices (interpreted):**
  - Adds/overwrites field `videoUrl` using `{{$json["body"]["text"] || ""}}`
  - **Include other fields:** enabled (passes everything through)
- **Key expressions/variables:**
  - `{{$json["body"]["text"] || ""}}`
- **Inputs/Outputs:**
  - Input from `Receive Slack command`
  - Output to `Extract YouTube video ID`
- **Failure/edge cases:**
  - If Slack payload structure differs (no `body.text`), `videoUrl` becomes empty. Downstream parsing will fail to find a video ID.

**Sticky note (applies to this block’s nodes):**  
“Receives the Slack command and normalizes the incoming payload.”

---

### Block 2 — YouTube ID Extraction & Duration Validation
**Overview:**  
Extracts an 11-character YouTube video ID from multiple possible URL formats, fetches the YouTube video duration via RapidAPI YouTube Data API endpoint, parses ISO-8601 duration, and enforces a 10-minute maximum.

**Nodes involved:**
- `Extract YouTube video ID`
- `Check Video Duration`
- `Parse and validate video duration`
- `Is video longer than limit?`
- `Send duration error to Slack`

#### Node: Extract YouTube video ID
- **Type / role:** Code node (JavaScript); robust URL parsing + ID extraction.
- **Configuration choices (interpreted):**
  - Removes a command prefix `"/rippit "` from the Slack text (note: your webhook path is `rippr`, but the code removes `/rippit`; mismatch is harmless unless users actually type a different command).
  - Extracts first URL from the text (or treats the entire text as URL).
  - Supports forms:
    - `youtube.com/watch?v=VIDEOID`
    - `youtu.be/VIDEOID`
    - `youtube.com/shorts/VIDEOID`
    - `youtube.com/embed/VIDEOID`
- **Key expressions/variables:**
  - Reads Slack text from: `inputJson?.body?.text ?? inputJson?.text ?? ''`
  - Regex: `/(?:youtube\.com\/watch\?v=|youtu\.be\/|shorts\/|embed\/)([A-Za-z0-9_-]{11})/i`
  - Outputs: `{ text, videoUrl, videoId }`
- **Inputs/Outputs:**
  - Input from `Normalize Slack payload`
  - Output to `Check Video Duration`
- **Failure/edge cases:**
  - If `videoId` is `null`, downstream nodes will call APIs with an invalid ID. There is **no explicit guard** for “invalid or missing video ID”.
  - Slack users may paste playlist URLs, channels, or other formats not matching the regex.

#### Node: Check Video Duration
- **Type / role:** HTTP Request; calls YouTube Data API via RapidAPI to get `contentDetails.duration`.
- **Configuration choices (interpreted):**
  - **URL:** `https://youtube-v31.p.rapidapi.com/videos?part=contentDetails&id={{videoId}}`
  - **Auth:** HTTP Header Auth credential named `RapidAPI`
  - **Header:** `x-rapidapi-host: youtube-v31.p.rapidapi.com`
  - (Implicitly requires RapidAPI key header in the credential)
- **Key expressions/variables:**
  - Uses `$('Extract YouTube video ID').item.json.videoId`
- **Inputs/Outputs:**
  - Input: from `Extract YouTube video ID`
  - Output: to `Parse and validate video duration`
- **Failure/edge cases:**
  - RapidAPI quota exceeded, invalid key, or wrong host header.
  - YouTube API may return empty `items` for invalid/private videos; downstream code assumes `items[0]` exists.

#### Node: Parse and validate video duration
- **Type / role:** Code node; parses ISO 8601 duration and applies max duration rule.
- **Configuration choices (interpreted):**
  - Reads duration from: `$input.item.json.items[0].contentDetails.duration`
  - Parses `PT#H#M#S`
  - Computes total minutes
  - Hard-coded limit: **10 minutes**
  - Does not throw errors; returns `{ error: true, errorMessage: ... }` for long videos
- **Key expressions/variables:**
  - Gets original fields from: `$('Extract YouTube video ID').first()`
  - Output includes: `error`, `errorMessage` (if too long), `videoId`, `videoUrl`, `durationMinutes`
- **Inputs/Outputs:**
  - Input: from `Check Video Duration`
  - Output: to `Is video longer than limit?`
- **Failure/edge cases:**
  - If `items[0]` missing or duration not matching regex, `match` may be `null` and `match[1]` will throw.
  - Limit is embedded in code; changing it requires editing JS.

#### Node: Is video longer than limit?
- **Type / role:** IF node; branches based on `error === true`.
- **Configuration choices:**
  - Condition: `{{$json.error}}` equals `true`
- **Inputs/Outputs:**
  - Input: from `Parse and validate video duration`
  - **True path:** `Send duration error to Slack`
  - **False path:** `Convert YouTube video to MP3`
- **Failure/edge cases:**
  - If prior node fails and doesn’t output `error`, condition evaluation may behave unexpectedly.

#### Node: Send duration error to Slack
- **Type / role:** HTTP Request; posts an error message back to Slack via `response_url`.
- **Configuration choices:**
  - **URL:** `{{$('Receive Slack command').item.json.body.response_url}}`
  - **Method:** POST
  - **Body:** `text = ❌ {{$json.errorMessage}}`
- **Inputs/Outputs:**
  - Input: from IF true branch
  - Output: none further (end)
- **Failure/edge cases:**
  - If `response_url` missing (non-Slack invocation), the request fails.
  - Slack `response_url` expires after some time; errors posted too late may be rejected.

**Sticky note (applies to this block’s nodes):**  
“Extracts the YouTube video ID and validates video duration before processing.”

---

### Block 3 — Convert YouTube to MP3 & Start AssemblyAI Transcription
**Overview:**  
Downloads the YouTube audio as an MP3 via RapidAPI, uploads the binary to AssemblyAI to obtain an `upload_url`, then creates a transcription job.

**Nodes involved:**
- `Convert YouTube video to MP3`
- ` Create transcription job`
- `Submit audio for transcription`

#### Node: Convert YouTube video to MP3
- **Type / role:** HTTP Request; fetches MP3 file from RapidAPI downloader endpoint.
- **Configuration choices (interpreted):**
  - **URL:** `https://youtube-mp3-audio-video-downloader.p.rapidapi.com/download-mp3/{videoId}?quality=low`
  - **Auth:** RapidAPI via HTTP Header Auth credential `RapidAPI`
  - Response:
    - `responseFormat: file`
    - output binary property name: `mp3`
    - `fullResponse: true`
    - `neverError: true` (important: even non-2xx responses won’t hard-fail the node)
  - Headers include:
    - `x-rapidapi-host: youtube-mp3-audio-video-downloader.p.rapidapi.com`
    - `accept: application/octet-stream`
    - `content-type : application/json` (note trailing space in header name; may be ignored by some servers)
- **Inputs/Outputs:**
  - Input: from duration check false branch
  - Output: binary `mp3` to ` Create transcription job`
- **Failure/edge cases:**
  - Because `neverError` is enabled, failures may appear as “successful” node executions but produce invalid/empty binary, causing AssemblyAI upload to fail.
  - RapidAPI services can return JSON error bodies instead of binary.

#### Node:  Create transcription job
- **Type / role:** HTTP Request; uploads MP3 binary to AssemblyAI `/upload`.
- **Configuration choices (interpreted):**
  - **URL:** `https://api.assemblyai.com/v2/upload`
  - **Method:** POST
  - **Body type:** binary data
  - **Binary property:** `mp3` (from previous node)
  - **Header:** `content-type: application/octet-stream`
  - **Auth:** HTTP Header Auth credential `AssemblyAI` (expects `authorization: <api-key>` typically)
  - Response format: JSON; expects `upload_url`
- **Inputs/Outputs:**
  - Input: binary from `Convert YouTube video to MP3`
  - Output: JSON including `upload_url` to `Submit audio for transcription`
- **Failure/edge cases:**
  - Missing/invalid AssemblyAI key → 401.
  - Upload size/timeouts for longer videos (even though duration is capped).
  - If MP3 binary is not present at `mp3`, upload will fail.

#### Node: Submit audio for transcription
- **Type / role:** HTTP Request; creates transcription job in AssemblyAI.
- **Configuration choices (interpreted):**
  - **URL:** `https://api.assemblyai.com/v2/transcript`
  - **Method:** POST
  - **JSON body:** `{ "audio_url": "{{$json.upload_url}}" }`
  - **Header:** `content-type: application/json`
  - **Auth:** AssemblyAI header auth
- **Inputs/Outputs:**
  - Input: JSON from upload step
  - Output: JSON containing transcription `id` to `Wait for transcription processing`
- **Failure/edge cases:**
  - `upload_url` missing → job creation fails.
  - AssemblyAI may return `error` fields if input is invalid.

**Sticky note (applies to this block’s nodes):**  
“Converts the video to audio and starts the transcription job.”

---

### Block 4 — Wait/Poll for AssemblyAI Completion & Extract Transcript
**Overview:**  
Implements polling: wait 20 seconds, check job status, loop until completed, then extract transcript text.

**Nodes involved:**
- `Wait for transcription processing`
- ` Check transcription status`
- `Extract transcript text`
- `Is transcription complete?`

#### Node: Wait for transcription processing
- **Type / role:** Wait node; introduces delay between status checks.
- **Configuration choices:**
  - Amount: `20` (seconds)
- **Inputs/Outputs:**
  - Input: from `Submit audio for transcription` (first loop) OR from `Is transcription complete?` false branch (subsequent loops)
  - Output: to ` Check transcription status`
- **Failure/edge cases:**
  - Many concurrent executions can accumulate waiting jobs; consider n8n queue/worker capacity.
  - No maximum retry count; could loop indefinitely if job stays “processing” or “queued” forever.

#### Node:  Check transcription status
- **Type / role:** HTTP Request; polls AssemblyAI transcript status endpoint.
- **Configuration choices (interpreted):**
  - **URL:** `https://api.assemblyai.com/v2/transcript/{{$node["Submit audio for transcription"].json["id"]}}`
  - Response format: JSON (expects `status`, and when complete, `text`)
  - Auth: AssemblyAI header auth
- **Inputs/Outputs:**
  - Input: from `Wait for transcription processing`
  - Output: to `Extract transcript text`
- **Failure/edge cases:**
  - If `Submit audio for transcription` did not run or has no `id`, URL becomes invalid.
  - AssemblyAI errors: `status` could be `error`; the workflow does not explicitly handle this.

#### Node: Extract transcript text
- **Type / role:** Code node; maps transcript text into a clean field.
- **Configuration choices (interpreted):**
  - Outputs:
    - `transcript: $json.text ?? ''` (from AssemblyAI status response)
    - `mode`: reads `mode` from `Normalize Slack payload` if present, else `'summary'`
- **Key expressions/variables:**
  - `($items('Normalize Slack payload', 0, 0)?.json?.mode) || 'summary'`
  - Note: `Normalize Slack payload` does not actually set `mode`, so this defaults to `'summary'` always unless added elsewhere.
- **Inputs/Outputs:**
  - Input: from ` Check transcription status`
  - Output: to `Is transcription complete?`
- **Failure/edge cases:**
  - If transcription is not complete, `$json.text` is often absent; transcript becomes empty (but completion is checked in next node based on `status` from a different node reference).

#### Node: Is transcription complete?
- **Type / role:** IF node; decides whether to proceed or keep waiting.
- **Configuration choices:**
  - Condition checks: `{{$node[" Check transcription status"].json["status"].toLowerCase()}}` equals `completed`
  - True branch → `Generate AI summary`
  - False branch → loops back to `Wait for transcription processing`
- **Inputs/Outputs:**
  - Input: from `Extract transcript text`
  - Branching described above
- **Failure/edge cases:**
  - If `status` is missing, `.toLowerCase()` throws an expression error.
  - No handling for `status: "error"`; it will loop forever.

**Sticky note (applies to this block’s nodes):**  
“Waits for transcription completion and retrieves the final transcript.”

---

### Block 5 — OpenAI Cleanup & Slack Posting
**Overview:**  
Uses OpenAI to reformat transcript into readable paragraphs (despite the node name suggesting summarization), then posts a branded message back to Slack using the original `response_url`.

**Nodes involved:**
- `Generate AI summary`
- `Post result to Slack`

#### Node: Generate AI summary
- **Type / role:** LangChain OpenAI node (`@n8n/n8n-nodes-langchain.openAi`); text transformation.
- **Configuration choices (interpreted):**
  - **Model:** `gpt-4-turbo`
  - **System message:** instructs model to *clean/reformat transcript*, explicitly says **do not summarize**
  - **User content:** transcript from `Extract transcript text`
- **Key expressions/variables:**
  - `{{$node["Extract transcript text"].json["transcript"]}}`
- **Inputs/Outputs:**
  - Input: from `Is transcription complete?` true branch
  - Output: to `Post result to Slack`
- **Failure/edge cases:**
  - OpenAI auth errors, model availability changes, rate limits.
  - Token limits for long transcripts; although video is capped at 10 minutes, transcripts can still be sizeable.
  - Node name is misleading: it performs cleaning, not summarization.

#### Node: Post result to Slack
- **Type / role:** HTTP Request; posts final message to Slack via `response_url`.
- **Configuration choices (interpreted):**
  - **URL:** `{{$node["Receive Slack command"].json["body"]["response_url"]}}`
  - **Method:** POST
  - **Body parameters:**
    - `response_type=in_channel` (broadcasts to channel)
    - `text=` branded header + original video link + OpenAI cleaned transcript
  - Pulls content primarily from:
    - `Generate AI summary` → `message.content`
    - Fallback expression for alternate output shapes
- **Key expressions/variables:**
  - Video link: `<{{$node["Extract YouTube video ID"].json["videoUrl"]}}|:film_projector: Original Video>`
  - Transcript content expression:  
    `{{$node["Generate AI summary"].json["message"]["content"] ?? ($json["message"] ? $json["message"][0]["content"] : "")}}`
- **Inputs/Outputs:**
  - Input: from `Generate AI summary`
  - Output: end
- **Failure/edge cases:**
  - Slack `response_url` may expire; long transcription times can cause posting failure.
  - Slack message length limits; large transcripts may be truncated/rejected. Consider splitting into multiple posts.

**Sticky note (applies to this block’s nodes):**  
“Formats the result and sends it back to Slack.”

---

## 3. Summary Table

| Node Name | Node Type | Functional Role | Input Node(s) | Output Node(s) | Sticky Note |
|---|---|---|---|---|---|
| Receive Slack command | Webhook | Entry point: receives Slack slash command and responds immediately | — | Normalize Slack payload | Receives the Slack command and normalizes the incoming payload. |
| Normalize Slack payload | Set | Maps Slack payload into normalized fields (`videoUrl`) | Receive Slack command | Extract YouTube video ID | Receives the Slack command and normalizes the incoming payload. |
| Extract YouTube video ID | Code | Extracts URL + YouTube 11-char video ID from Slack text | Normalize Slack payload | Check Video Duration | Extracts the YouTube video ID and validates video duration before processing. |
| Check Video Duration | HTTP Request | Calls YouTube Data API via RapidAPI to retrieve ISO duration | Extract YouTube video ID | Parse and validate video duration | Extracts the YouTube video ID and validates video duration before processing. |
| Parse and validate video duration | Code | Parses ISO-8601 duration and enforces 10-minute limit | Check Video Duration | Is video longer than limit? | Extracts the YouTube video ID and validates video duration before processing. |
| Is video longer than limit? | If | Branches: send Slack error vs continue processing | Parse and validate video duration | Send duration error to Slack; Convert YouTube video to MP3 | Extracts the YouTube video ID and validates video duration before processing. |
| Send duration error to Slack | HTTP Request | Posts error back to Slack via `response_url` | Is video longer than limit? (true) | — | Extracts the YouTube video ID and validates video duration before processing. |
| Convert YouTube video to MP3 | HTTP Request | Downloads MP3 via RapidAPI and outputs binary `mp3` | Is video longer than limit? (false) |  Create transcription job | Converts the video to audio and starts the transcription job. |
|  Create transcription job | HTTP Request | Uploads MP3 binary to AssemblyAI `/upload` to get `upload_url` | Convert YouTube video to MP3 | Submit audio for transcription | Converts the video to audio and starts the transcription job. |
| Submit audio for transcription | HTTP Request | Creates AssemblyAI transcript job from `upload_url` |  Create transcription job | Wait for transcription processing | Converts the video to audio and starts the transcription job. |
| Wait for transcription processing | Wait | Delays before polling again (20s) | Submit audio for transcription; Is transcription complete? (false) |  Check transcription status | Waits for transcription completion and retrieves the final transcript. |
|  Check transcription status | HTTP Request | Polls AssemblyAI transcript job status and retrieves text when ready | Wait for transcription processing | Extract transcript text | Waits for transcription completion and retrieves the final transcript. |
| Extract transcript text | Code | Outputs `{transcript, mode}` from AssemblyAI response |  Check transcription status | Is transcription complete? | Waits for transcription completion and retrieves the final transcript. |
| Is transcription complete? | If | If completed → proceed; else loop wait/poll | Extract transcript text | Generate AI summary; Wait for transcription processing | Waits for transcription completion and retrieves the final transcript. |
| Generate AI summary | OpenAI (LangChain) | Cleans/reformats transcript text (no summarization) | Is transcription complete? (true) | Post result to Slack | Formats the result and sends it back to Slack. |
| Post result to Slack | HTTP Request | Posts final transcript back to Slack channel via `response_url` | Generate AI summary | — | Formats the result and sends it back to Slack. |
| Sticky Note16 | Sticky Note | Documentation (“How it works” + setup steps) | — | — |  |
| Sticky Note | Sticky Note | Comment: Slack reception block | — | — |  |
| Sticky Note1 | Sticky Note | Comment: YouTube extraction + duration validation | — | — |  |
| Sticky Note2 | Sticky Note | Comment: conversion + transcription job start | — | — |  |
| Sticky Note3 | Sticky Note | Comment: waiting + completion | — | — |  |
| Sticky Note4 | Sticky Note | Comment: formatting + Slack send | — | — |  |

---

## 4. Reproducing the Workflow from Scratch

1) **Create Webhook trigger**
   1. Add node **Webhook** named `Receive Slack command`.
   2. Set **HTTP Method** = `POST`.
   3. Set **Path** = `rippr`.
   4. In **Response**, set a text response like:  
      `🗡️ Ripping the full transcript… wait a few minutes, I’ll post it here soon (• v •)`

2) **Normalize Slack payload**
   1. Add node **Set** named `Normalize Slack payload`.
   2. Enable **Include Other Fields**.
   3. Add field `videoUrl` (String) with expression:  
      `{{$json.body.text || ""}}`
   4. Connect: `Receive Slack command` → `Normalize Slack payload`.

3) **Extract YouTube video ID**
   1. Add node **Code** named `Extract YouTube video ID`.
   2. Paste logic that:
      - reads Slack text from `body.text`
      - optionally strips `/rippit`
      - extracts first URL
      - extracts video ID using regex for watch/youtu.be/shorts/embed
      - outputs `{ videoUrl, videoId, text }`
   3. Connect: `Normalize Slack payload` → `Extract YouTube video ID`.

4) **RapidAPI: check video duration (YouTube Data API)**
   1. Add node **HTTP Request** named `Check Video Duration`.
   2. Set URL to:  
      `https://youtube-v31.p.rapidapi.com/videos?part=contentDetails&id={{$('Extract YouTube video ID').item.json.videoId}}`
   3. Set **Authentication** to **Generic Credential Type** → **HTTP Header Auth**.
   4. Create credential **RapidAPI** that sends your RapidAPI key header (commonly `X-RapidAPI-Key`).
   5. Add header: `x-rapidapi-host = youtube-v31.p.rapidapi.com`
   6. Connect: `Extract YouTube video ID` → `Check Video Duration`.

5) **Parse duration + enforce max length**
   1. Add node **Code** named `Parse and validate video duration`.
   2. Implement:
      - read `items[0].contentDetails.duration`
      - parse ISO `PT#H#M#S`
      - compute total minutes
      - if `> 10`, output `{ error: true, errorMessage, videoId, videoUrl }`
      - else output `{ error: false, videoId, videoUrl, durationMinutes }`
   3. Connect: `Check Video Duration` → `Parse and validate video duration`.

6) **IF: duration too long**
   1. Add node **IF** named `Is video longer than limit?`
   2. Condition: `{{$json.error}}` **equals** `true`.
   3. Connect: `Parse and validate video duration` → `Is video longer than limit?`

7) **Slack error path**
   1. Add node **HTTP Request** named `Send duration error to Slack`.
   2. Method: POST
   3. URL: `{{$('Receive Slack command').item.json.body.response_url}}`
   4. Body: send `text = ❌ {{$json.errorMessage}}`
   5. Connect IF **true** → `Send duration error to Slack`.

8) **Convert YouTube to MP3 (RapidAPI)**
   1. Add node **HTTP Request** named `Convert YouTube video to MP3`.
   2. URL:  
      `https://youtube-mp3-audio-video-downloader.p.rapidapi.com/download-mp3/{{$json.videoId}}?quality=low`
   3. Authentication: use the same **RapidAPI** HTTP Header Auth credential.
   4. Add headers:
      - `x-rapidapi-host = youtube-mp3-audio-video-downloader.p.rapidapi.com`
      - `accept = application/octet-stream`
   5. Response settings:
      - Response Format = **File**
      - Binary Property = `mp3`
      - (Optional) “Never Error” if you want the same behavior, but note it can mask failures.
   6. Connect IF **false** → `Convert YouTube video to MP3`.

9) **AssemblyAI: upload binary**
   1. Add node **HTTP Request** named ` Create transcription job`.
   2. Method: POST
   3. URL: `https://api.assemblyai.com/v2/upload`
   4. Authentication: **HTTP Header Auth** credential named `AssemblyAI` (send AssemblyAI API key, usually `authorization` header).
   5. Set body type to **Binary Data**, binary field = `mp3`.
   6. Add header: `content-type = application/octet-stream`
   7. Connect: `Convert YouTube video to MP3` → ` Create transcription job`.

10) **AssemblyAI: create transcript job**
   1. Add node **HTTP Request** named `Submit audio for transcription`.
   2. Method: POST
   3. URL: `https://api.assemblyai.com/v2/transcript`
   4. Authentication: `AssemblyAI` credential.
   5. Send JSON body: `{ "audio_url": "{{$json.upload_url}}" }`
   6. Connect: ` Create transcription job` → `Submit audio for transcription`.

11) **Wait + Poll loop**
   1. Add node **Wait** named `Wait for transcription processing`, amount = `20` seconds.
   2. Connect: `Submit audio for transcription` → `Wait for transcription processing`.
   3. Add node **HTTP Request** named ` Check transcription status`.
      - Method: GET
      - URL: `https://api.assemblyai.com/v2/transcript/{{$node["Submit audio for transcription"].json["id"]}}`
      - Auth: `AssemblyAI`
   4. Connect: `Wait for transcription processing` → ` Check transcription status`.

12) **Extract transcript**
   1. Add node **Code** named `Extract transcript text`.
   2. Output: `transcript = $json.text ?? ''` and a `mode` (optional).
   3. Connect: ` Check transcription status` → `Extract transcript text`.

13) **IF: transcription complete**
   1. Add node **IF** named `Is transcription complete?`
   2. Condition: `{{$node[" Check transcription status"].json.status.toLowerCase()}}` equals `completed`
   3. Connect: `Extract transcript text` → `Is transcription complete?`
   4. Connect IF **false** → back to `Wait for transcription processing` (this forms the polling loop).

14) **OpenAI cleanup**
   1. Add node **OpenAI (LangChain)** named `Generate AI summary` (name optional).
   2. Credentials: configure **OpenAI API** credential.
   3. Model: `gpt-4-turbo` (or your preferred equivalent).
   4. Messages:
      - System: instructions to reformat transcript and **not summarize**
      - User: `{{$node["Extract transcript text"].json.transcript}}`
   5. Connect IF **true** → `Generate AI summary`.

15) **Post back to Slack**
   1. Add node **HTTP Request** named `Post result to Slack`.
   2. Method: POST
   3. URL: `{{$node["Receive Slack command"].json.body.response_url}}`
   4. Body:
      - `response_type = in_channel`
      - `text =` include branding + original video link + OpenAI output content
   5. Connect: `Generate AI summary` → `Post result to Slack`.

**Credentials required:**
- **RapidAPI (HTTP Header Auth):** must include your RapidAPI key header (commonly `X-RapidAPI-Key`) used by both RapidAPI endpoints.
- **AssemblyAI (HTTP Header Auth):** typically header `authorization: <ASSEMBLYAI_API_KEY>`.
- **OpenAI:** n8n OpenAI credential.

---

## 5. General Notes & Resources

| Note Content | Context or Link |
|---|---|
| “How it works” + setup checklist is embedded in a sticky note in the workflow canvas. | Internal workflow documentation (Sticky Note16) |
| The workflow enforces a **10-minute** duration limit in code, not in a parameter. | Edit `Parse and validate video duration` to change the limit. |
| Polling loop has **no max retries** and does not handle AssemblyAI `status=error`. | Consider adding an error branch + retry limit to avoid infinite runs. |
| The OpenAI node is named “Generate AI summary” but prompt instructs **cleanup only**, not summarization. | Rename node if you want clarity, or change the system prompt if you truly want summaries. |

disclaimer Le texte fourni provient exclusivement d’un workflow automatisé réalisé avec n8n, un outil d’intégration et d’automatisation. Ce traitement respecte strictement les politiques de contenu en vigueur et ne contient aucun élément illégal, offensant ou protégé. Toutes les données manipulées sont légales et publiques.