---
title: "Text turned into spoken MP3 audio with OpenAI"
kind: "Kit"
category: "Productivity"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/02c46792-030a-4bbd-8fcd-c780a165f2fe"
updated: "2026-11-12"
---

# Text turned into spoken MP3 audio with OpenAI

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow you start by hand: a Set node holds a line of text and a voice, and OpenAI’s text to speech endpoint returns it as an MP3 file. Change the two fields to speak anything.

Text turned into spoken MP3 audio with OpenAI is an n8n workflow in the Productivity category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-12. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow turns text into spoken audio. A manual trigger starts it. A Set node holds the text and the voice name, and one HTTP request sends both to OpenAI’s speech endpoint with the `tts-1` model. OpenAI answers with an MP3 file, which stays in the run as a binary file. Three nodes do the work, beside five sticky notes that label the steps.

### Who it suits

Developers and creators who want a small starting block for voice output, such as narration for a video, a spoken alert or a read-aloud button. Skip it if the audio must be saved or sent on. As imported, it stays in the run.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Video and podcasts | Creators | Turn a script into a voice track, one paragraph at a time | A creator makes an MP3 of a short intro and drops it into a video editor. |
| Education | Teachers | Make a read-aloud version of a short reading | A teacher turns a lesson summary into audio for the class. |
| Customer support | Support teams | Hear a reply aloud before building it into a phone flow | A team tries several voices on the same greeting. |
| Development | Builders | Swap the manual trigger for a webhook | An app asks the workflow for audio and gets a file back. |

You need a little n8n: import a file, select one OpenAI credential and edit one Set node.

### Where to use it

Any n8n that can reach OpenAI’s API will run it. Decide where the file should go, since nothing saves it.

- n8n Cloud: import the file into a new workflow there
- Your own n8n server: the same file and steps
- An audio or video editor: download the MP3 from the run’s output
- Email, chat or a drive: add a node after the request to send or store the file

### How to set it up

Download saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. One OpenAI key covers it.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server of your own |
| OpenAI | An API key for an OpenAI credential |
| Some text | One passage for each run, kept short |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Add an OpenAI credential with your key and select it in `Send HTTP Request to OpenAI's TTS Endpoint`.
3. Open `Set input text and TTS voice`. Replace `input_text` with your text and keep `voice` as `alloy`, or pick another voice from OpenAI’s speech guide.
4. Press Execute workflow. Open the last node’s output and play or download the file on its Binary tab.

### How to use it

Type your text into `input_text`, choose a `voice` and press Execute workflow. One request goes to OpenAI, and the MP3 sits in the request’s output as a file named `data`.

What to change for a different result

| To change | Where |
| --- | --- |
| The text | \`input\_text\` in \`Set input text and TTS voice\` |
| The voice | \`voice\` in the same node |
| The model | \`model\` in the request’s body, \`tts-1\` in the file |
| How it starts | Replace the manual trigger with a webhook, a schedule or another trigger |
| Where the audio goes | Add a node after the request |

### Example

A teacher puts a three-sentence lesson summary into `input_text` and keeps the voice `alloy`.

The request’s output holds one MP3 file. Its Binary tab shows a player, and any node you add after it can send or store the same file.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. This one has three in a row: the button, the settings and the request. One press makes one request and one MP3. Start with one short sentence, then try a longer text.

**For experts.** The request is a plain call to the speech endpoint, and the credential adds the key.

Where to look closer

| Node | What it does | What to know |
| --- | --- | --- |
| \`Set input text and TTS voice\` | Set 3.2 in raw JSON mode with two fields | Replace the JSON with values from an earlier step to feed it from outside |
| \`Send HTTP Request to OpenAI's TTS Endpoint\` | HTTP Request 4.1, POST with \`model\`, \`input\` and \`voice\` in the body | The \`openAiApi\` credential adds the Authorization header, and the answer comes back as a file |

### Good to know

The model is on its way out, and the original copy sent a stray header.

- Model: OpenAI’s deprecations page, read on 12 November 2026, shuts down \`tts-1\` on 6 January 2027. The replacement it names, \`gpt-realtime-2.1-mini\`, is a Realtime API model, and OpenAI’s speech guide says it is not supported on the speech endpoint. Mindket’s copy keeps \`tts-1\`, which works until then. Plan a rebuild on the Realtime API before that date
- Header: the original copy added a header with the literal text \`Bearer $OPENAI\_API\_KEY\` beside its credential. Mindket’s copy drops it, since the credential sends your key
- Length: the note on the canvas puts one call’s limit at 4,000 tokens, so send long texts in pieces
- Disclosure: OpenAI’s usage policies, as its speech guide states them, require you to tell listeners the voice is AI-generated
- Billing: OpenAI bills each call to your key
- Your data: the text goes to OpenAI
- Credentials: the JSON holds none

## README

```markdown
# Text turned into spoken MP3 audio with OpenAI

An n8n workflow you start by hand. A Set node holds a line of text and a voice name, and one HTTP request sends both to
OpenAI's speech endpoint with the `tts-1` model. OpenAI answers with an MP3 file that stays in the run as a binary
file.

## What is inside

- `workflow.json`: the workflow as n8n exports it, eight nodes. Three do the work and five are sticky notes that label
  the steps and list the options. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

- The request carried a header named `Authorization` with the literal text `Bearer $OPENAI_API_KEY`, beside an OpenAI
  credential that already sends your key. The literal text is not a key, so Mindket's copy drops the header and lets
  the credential do the work.
- The request was linked to a credential in its author's n8n. The link is gone, so select your own.
- Nothing else. The text, the voice, the model and the sticky notes are the file's own.

## Before you start

- An n8n instance, on n8n Cloud or your own server.
- An OpenAI API key, for an OpenAI credential.
- A short text to speak.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Add an OpenAI credential with your key and select it in `Send HTTP Request to OpenAI's TTS Endpoint`.
3. Open `Set input text and TTS voice`. Replace `input_text` with your text. Keep `voice` as `alloy`, or pick another
   voice from OpenAI's speech guide.
4. Press Execute workflow. Open the last node's output and play or download the file on its Binary tab.

## How a run goes

1. The manual trigger starts the run when you press Execute workflow.
2. `Set input text and TTS voice` (Set 3.2, raw JSON mode) holds `input_text` and `voice`. The file has a short test
   sentence and `alloy`.
3. `Send HTTP Request to OpenAI's TTS Endpoint` (HTTP Request 4.1) posts `model`, `input` and `voice` to
   `https://api.openai.com/v1/audio/speech`. It signs in with the `openAiApi` credential type, and the answer comes
   back as a file named `data`.

## Change the look

- Text and voice: `input_text` and `voice` in the Set node. Replace the JSON with values from an earlier step to feed it
  from a webhook, a sheet or a schedule.
- Model: `model` in the request's body.
- How it starts: replace the manual trigger with another trigger.
- Where the audio goes: add a node after the request, such as Google Drive, Gmail or Slack.

## Good to know

- OpenAI's deprecations page, read on 12 November 2026, shuts down `tts-1` on 6 January 2027. The replacement it names,
  `gpt-realtime-2.1-mini`, is a Realtime API model, and OpenAI's speech guide says it is not supported on the speech
  endpoint. The copy keeps `tts-1`, which works until then. Plan a rebuild on the Realtime API before that date.
- The note on the canvas puts one call's limit at 4,000 tokens. Send longer texts in pieces.
- OpenAI's usage policies, as its speech guide states them, require you to tell listeners that the voice is
  AI-generated.
- OpenAI bills each call to your key.
- The text goes to OpenAI.
- The file holds no credential and no key.
```

## What is in it

3 files, 8 KB, downloaded as a zip.

```text
NOTICE.md  585 B
README.md  3 KB
workflow.json  5 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 3 steps, starting by hand
- AI: No step calls an AI model
- Sign-ins: Signs in to: OpenAI
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 3 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/02c46792-030a-4bbd-8fcd-c780a165f2fe)
- [Its page on Mindket](https://mindket.com/p/02c46792-030a-4bbd-8fcd-c780a165f2fe)
