Menu

Mattering Automations ElevenLabs integration

Connect ElevenLabs to Mattering Automations: text to speech, Scribe transcription from a URL, asynchronous dubbing, sound effects, voice and pronunciation dictionary management, and the Conversational AI agents platform, authenticated with an API key sent as the xi-api-key header.

The Mattering Automations ElevenLabs integration adds ElevenLabs voice AI to your automation canvas: convert text to speech with any voice on the account, in a binary shape or a JSON shape with per-character timing; generate sound effects from a text description; transcribe audio and video with Scribe from a URL, with speaker diarization and word timestamps; dub media into another language through an asynchronous job lifecycle; search the public voice library and manage voices, their settings, and pronunciation dictionaries; watch models, subscription, and credit usage; and run the Conversational AI agents platform, from creating agents to reading call transcripts and post-call analysis.

Setup takes a few minutes: create an API key in the ElevenLabs dashboard, attach it as a credential in Mattering, and test the connection. This guide walks through each step and ends with the full node reference.

Four facts shape how this integration behaves. The API key travels in the custom header xi-api-key, not an Authorization Bearer header, and the integration formats it for you. Media goes in as a URL that ElevenLabs fetches itself, never as an upload. Generated audio comes back as base64 inside the node output under a 5 MB encoded cap, with a JSON-native text to speech variant when downstream steps consume the result. And billing is one shared credit pool with concurrency-based limits per plan rather than requests per minute.

Before you start

  • An ElevenLabs account. The free plan includes API access with 10,000 credits per month, which covers testing every node family here, but free-tier output carries no commercial license and is limited to non-commercial use with attribution to ElevenLabs; commercial licensing starts at the Starter plan. Current plans are at elevenlabs.io/pricing.
  • An ElevenLabs API key, created from the profile menu under API Keys. Either an unrestricted key, or one granted the products your nodes will touch: keys can be restricted per product, and a restricted key returns 401 with a missing_permissions message on products it lacks.
  • A Mattering workspace with access to the Automations app.
  • For transcription and dubbing: audio or video reachable at a URL that ElevenLabs can fetch, up to 2 GB for transcription. A public HTTPS link works, and so does a time-limited signed link from object storage. There is no file upload path on the canvas.

Create an ElevenLabs API key

Mattering authenticates to ElevenLabs with an API key sent as the custom header xi-api-key on every request. The credential is a single secret value: the connect form asks for the key and nothing else, and the integration formats the header itself.

Sign in at elevenlabs.io and open your profile menu.
Open API Keys and click Create API Key.
Choose the key's permissions. An unrestricted key runs every node in this integration; a restricted key must be granted each product your automations will use, such as text to speech, speech to text, dubbing, sound generation, and Conversational AI.
Copy the key value.
A restricted key fails with 401 missing_permissions on any product it was not granted, even though the key is valid. The connection test reads the voices list, which most keys can access, so a restricted key can pass the test and still fail later on, for example, a dubbing node. If a single node family returns 401 while everything else works, check the key's restrictions first.
ElevenLabs uses the custom header xi-api-key, not Authorization with a Bearer scheme. Inside this integration you never type the header, because the connector builds it for you; it only becomes your problem if you also call ElevenLabs from a generic HTTP node.

Connect ElevenLabs to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose ElevenLabs from the list.
Click Create new credential, paste the API key into the single value field, and save. There is no header name to type; the integration sends xi-api-key for you.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs.
Click Test Connection. Mattering calls the ElevenLabs voices list, which is free, read-only, and available on every tier including the free plan; a bad key fails it immediately.
Click Connect. All 37 ElevenLabs nodes appear in your canvas palette.

Verify it works

After connecting, open any automation canvas and check the palette: an ElevenLabs section should list the query and action nodes. Drop ElevenLabs: List Voices onto the canvas and run a test step. It takes no configuration, costs nothing, and doubles as the credential health check; a successful response lists the account's voices with their voice_id values, which every speech node needs. Follow it with ElevenLabs: List Models to see the available models with their character caps and pick a model_id, and ElevenLabs: Get Subscription to read the tier and how many credits remain this month. Everything in this path is a free read.

Save the first metered call for when you are ready: ElevenLabs: Text to Speech with a single short sentence and a voice_id from the list is the honest smoke test. It spends a few credits from the monthly pool, well inside the free plan's 10,000, and returns the audio as base64 with its content type and byte size, which confirms the whole path from credential to spoken audio.

Node reference

37 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 21

ElevenLabs: Get Agent

elevenlabs_get_agent

Get one Conversational AI agent's full configuration: prompt, first message, language, voice and conversation settings.

ElevenLabs: Get Character Usage

elevenlabs_get_character_usage

Get credit usage over a time window as parallel time and usage arrays, optionally broken down by voice, model, API key or user and bucketed by hour, day, week or month. Note: the docs mark this endpoint deprecated in favor of a newer workspace analytics query, but it remains the simple documented usage read.

ElevenLabs: Get Conversation

elevenlabs_get_conversation

Get one conversation's full detail: the turn-by-turn transcript with tool calls, call metadata (duration, cost) and the post-call analysis (summary, success evaluation, collected data).

ElevenLabs: Get Default Voice Settings

elevenlabs_get_default_voice_settings

Get the workspace default voice settings (stability, similarity boost, style, speed, speaker boost) applied to new voices and used when a request omits voice_settings.

ElevenLabs: Get Dubbed Audio

elevenlabs_get_dub_audio

Download the dubbed media for one language of a finished dub. Returns base64 (data.audio_base64) with content type and byte size, subject to the 5 MB encoded cap - fine for short audio dubs; full videos will exceed it and must be downloaded outside the canvas.

ElevenLabs: Get Dubbing

elevenlabs_get_dub

Get a dubbing project's status and metadata. status moves from dubbing to dubbed (or failed with an error message); poll this between Dub Media from URL and the transcript or audio nodes.

ElevenLabs: Get Dubbing Transcript

elevenlabs_get_dub_transcript

Get the transcript of a finished dub in one of its languages as subtitle text (SRT by default, or WebVTT). Returns the raw subtitle document at data.text - ready to pipe into a file or captioning step.

ElevenLabs: Get History Audio

elevenlabs_get_history_audio

Download the audio of a previously generated item without paying to regenerate it. Returns base64 audio (data.audio_base64) with content type and byte size, subject to the 5 MB encoded cap; longer clips exceed it and must be fetched outside the canvas. The bulk zip download endpoint (POST /v1/history/download) is not shipped for the same reason.

ElevenLabs: Get History Item

elevenlabs_get_history_item

Get one generated item's metadata: the text, voice, model, date and character cost. For the audio itself use Get History Audio.

ElevenLabs: Get Pronunciation Dictionary

elevenlabs_get_pronunciation_dictionary

Get one pronunciation dictionary's metadata including its latest version ID and rule count.

ElevenLabs: Get Subscription

elevenlabs_get_subscription

Get extended subscription details: tier, credits used vs the monthly limit, the reset timestamp, voice slot usage and feature entitlements. The natural guard node before a big TTS batch.

ElevenLabs: Get User Info

elevenlabs_get_user

Get the account behind the API key: user ID, name, onboarding state and a summary of the subscription including characters used and the monthly limit.

ElevenLabs: Get Voice

elevenlabs_get_voice

Get full metadata for one voice: name, category, labels, description, preview URL, saved settings and fine-tuning state.

ElevenLabs: Get Voice Settings

elevenlabs_get_voice_settings

Get the saved settings for one voice: stability, similarity boost, style, speed and speaker boost.

ElevenLabs: List Agents

elevenlabs_list_agents

List the workspace's Conversational AI agents with their IDs, names, tags and creation times.

ElevenLabs: List Conversations

elevenlabs_list_conversations

List Conversational AI calls with duration, message count, status and success evaluation - the feed for call-log and QA automations.

ElevenLabs: List History

elevenlabs_list_history

List previously generated audio items with their text, voice, model and character cost. Paginate with start_after_history_item_id from the previous response's last_history_item_id.

ElevenLabs: List Models

elevenlabs_list_models

List every available model with its capabilities (text to speech, voice conversion, style support), supported languages, character caps and cost factors. Use it to pick a model_id for the speech nodes.

ElevenLabs: List Pronunciation Dictionaries

elevenlabs_list_pronunciation_dictionaries

List the workspace's pronunciation dictionaries with their IDs, latest version IDs and rule counts. Dictionary id plus version_id is the locator shape TTS nodes accept in pronunciation_dictionary_locators.

ElevenLabs: List Voices

elevenlabs_list_voices

List the voices available to this account - premade, cloned, generated and library-saved - with their voice IDs, settings and metadata. Filter by search text, type or category. This is the free lookup that feeds voice_id into every speech node, and the credential health check for the connector.

ElevenLabs: Search Voice Library

elevenlabs_search_voice_library

Search the public ElevenLabs voice library of community and professional shared voices by text, gender, age, accent, language and use case. Each result carries the public_owner_id and voice_id needed by the Add Shared Voice node.

Action nodes 16

ElevenLabs: Add Pronunciation Rules

elevenlabs_add_pronunciation_rules

Add rules to an existing pronunciation dictionary, creating a new version. A rule with the same string_to_replace as an existing one replaces it. Reversible with Remove Pronunciation Rules.

ElevenLabs: Add Shared Voice

elevenlabs_add_shared_voice

Add a voice from the public voice library to this account's voices under a name of your choosing. Uses a voice slot; reversible with the Delete Voice node. Get public_user_id and voice_id from the Search Voice Library node.

ElevenLabs: Create Agent

elevenlabs_create_agent

Create a Conversational AI agent from a conversation_config object (prompt, first message, language, voice). Returns the new agent_id; reversible with Delete Agent. Running conversations with the agent bills credits per minute.

ElevenLabs: Create Pronunciation Dictionary

elevenlabs_create_pronunciation_dictionary

Create a pronunciation dictionary from a JSON list of rules (no file upload needed). Rules are alias replacements ('AI' spoken as 'ay eye') or phoneme overrides in IPA or CMU. Returns the new dictionary id and version_id to use in TTS pronunciation_dictionary_locators.

ElevenLabs: Delete Agent

elevenlabs_delete_agent

Permanently delete a Conversational AI agent and its configuration.

ElevenLabs: Delete Conversation

elevenlabs_delete_conversation

Permanently delete a conversation record including its transcript, analysis and audio.

ElevenLabs: Delete Dubbing

elevenlabs_delete_dub

Permanently delete a dubbing project including its dubbed media and transcripts. Does not refund the credits spent.

ElevenLabs: Delete History Item

elevenlabs_delete_history_item

Permanently delete one generated item and its audio from the account history. Does not refund the characters spent.

ElevenLabs: Delete Voice

elevenlabs_delete_voice

Permanently delete a voice from this account. Cloned and generated voices cannot be recovered; premade voices cannot be deleted. Frees a voice slot.

ElevenLabs: Dub Media from URL

elevenlabs_create_dub_from_url

Start an automatic dubbing job that translates and revoices audio or video from a URL into a target language, keeping the speakers' voice character. Returns a dubbing_id immediately; the job runs asynchronously - poll Get Dubbing until status is dubbed, then fetch the transcript or audio. Billed in credits by media duration. Direct file upload is not supported on the canvas - host the media at a URL first.

ElevenLabs: Edit Voice Settings

elevenlabs_edit_voice_settings

Update the saved settings for one voice. Omitted fields keep their current values; read them first with Get Voice Settings if you need to restore later.

ElevenLabs: Generate Sound Effect

elevenlabs_create_sound_effect

Generate a sound effect from a text description (e.g. 'heavy rain on a tin roof'). Returns the audio as base64 (data.audio_base64) with content type and byte size, subject to the 5 MB encoded cap. Billed in credits; effects are 0.5 to 30 seconds long.

ElevenLabs: Remove Pronunciation Rules

elevenlabs_remove_pronunciation_rules

Remove rules from a pronunciation dictionary by their string_to_replace values, creating a new version. The inverse of Add Pronunciation Rules - re-adding the same rules restores them.

ElevenLabs: Text to Speech

elevenlabs_text_to_speech

Convert text into speech with an ElevenLabs voice. Returns the audio as base64 (data.audio_base64) with its content type and byte size; responses over the 5 MB encoded cap fail with a clear error, so use a lower-bitrate output_format or shorter text for long passages. Billed in credits per character. For JSON output with per-character timing use the Text to Speech with Timestamps node instead.

ElevenLabs: Text to Speech with Timestamps

elevenlabs_text_to_speech_timestamps

Convert text into speech and get a JSON response containing the audio as base64 (data.audio_base64) plus per-character start and end times in seconds (data.alignment) - the shape subtitle and karaoke-style pipelines need. Same billing as plain text to speech. This is the JSON-native TTS node, so prefer it when downstream nodes consume the output.

ElevenLabs: Transcribe Audio from URL

elevenlabs_speech_to_text_url

Transcribe an audio or video file with ElevenLabs Scribe by pointing at a public HTTPS URL (up to 2 GB) - no upload needed. Returns the transcript text with per-word timestamps, optional speaker diarization and audio-event tags. Billed by audio duration. The request is held open while the file is processed, so long media can take minutes; this node allows up to 5. Direct file upload is not supported on the canvas - host the file at a URL first.

Using the integration

On the automation canvas

ElevenLabs nodes chain with every other node. Article text arriving on a webhook can run through ElevenLabs: Text to Speech and attach as narrated audio to a task in Mattering Productivity; a recording URL can run through ElevenLabs: Transcribe Audio from URL and land as a transcript row in a Mattering database; and a scheduled ElevenLabs: Get Subscription can message a channel before a batch job runs the credit pool dry. The read nodes for voices, models, history, dictionaries, and conversations are free, so they can run on schedules without watching the meter.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the assistant built into the platform. An assistant can pick a voice from the library, narrate a document, transcribe a call, or summarize yesterday's agent conversations through the same nodes your workflows use. ElevenLabs also ships an official MCP server of its own; the difference here is that these nodes live inside a work platform, so the same operations run unattended in scheduled automations and their output lands in tasks and databases rather than in a chat window.

Audio in is a URL, not an upload

There is no file upload box on ElevenLabs: Transcribe Audio from URL or ElevenLabs: Dub Media from URL, and there is not meant to be one: both send ElevenLabs a URL and ElevenLabs fetches the media itself, up to 2 GB for transcription. An automation canvas cannot produce a file-upload request body, so the ElevenLabs endpoints that only accept uploaded files, audio isolation and forced alignment among them, are not shipped at all rather than shipped broken. A public HTTPS link works; so does a signed or temporary URL from object storage, as long as it has not expired by the time the node runs. If the media only exists locally, put it somewhere fetchable first.

Audio out is base64 under a 5 MB cap

ElevenLabs: Text to Speech, ElevenLabs: Generate Sound Effect, ElevenLabs: Get History Audio, and ElevenLabs: Get Dubbed Audio return audio as base64 at data.audio_base64, with a content type and byte size beside it, capped at 5 MB encoded. A response over the cap fails with a clear error instead of a truncated blob; the fix is a lower-bitrate output_format or shorter text. At the default mp3_44100_128 the cap is roughly 4 minutes of audio, and at mp3_22050_32 roughly 16 minutes. When the next node consumes the result as data rather than sound, prefer ElevenLabs: Text to Speech with Timestamps: ElevenLabs itself returns JSON there, with the base64 audio plus per-character start and end times, the shape subtitle and karaoke pipelines need. Bulk downloads such as the history zip endpoint are not shipped for the same size reason.

Dubbing is create, poll, fetch

Dubbing jobs are asynchronous. ElevenLabs: Dub Media from URL starts the job and returns a dubbing_id immediately; ElevenLabs: Get Dubbing reads its status as it moves from dubbing to dubbed, or to failed with an error message; and once it lands, ElevenLabs: Get Dubbing Transcript returns the subtitle text as SRT or WebVTT and ElevenLabs: Get Dubbed Audio returns the dubbed track for one language as base64 under the 5 MB cap. Short audio dubs fit; full dubbed videos exceed the cap and are downloaded from the ElevenLabs dashboard instead. Dubbing is billed by media duration and is the most expensive family per second of media, so test it with a clip of a few seconds.

Credits, concurrency, and character caps

Every ElevenLabs product bills from one shared monthly credit pool: text to speech per character, transcription and dubbing by media duration, Conversational AI per minute. ElevenLabs: Get Subscription reads credits used against the monthly limit and the reset timestamp, which makes it the natural guard before a batch run, and ElevenLabs: Get Character Usage breaks spend over a time window down by voice, model, or API key. Limits are concurrency-based per plan rather than requests per minute, so a flow that fans out too many simultaneous generations gets 429 responses, surfaced as failed step outputs rather than crashes. Per-request text length is capped per model, and ElevenLabs: List Models shows each model's cap alongside its languages and capabilities. No prices or per-plan numbers are quoted in node descriptions, because they change; elevenlabs.io/pricing and the ElevenLabs models documentation are the sources.

Voice cloning is deliberately not included

ElevenLabs' terms require consent from the voice's owner before cloning, and that consent is a per-sample legal judgement a human should make, not something to put one node away from an automation loop. So the cloning endpoints are not part of this integration. The consent-safe path is: ElevenLabs: Search Voice Library searches the public library of community and professional voices already published under their owners' terms, filterable by gender, age, accent, language, and use case, and ElevenLabs: Add Shared Voice saves one to the account using a voice slot, reversible with ElevenLabs: Delete Voice. Voices already cloned in the ElevenLabs dashboard appear in ElevenLabs: List Voices and work in every speech node. Also out of scope: streaming and WebSocket endpoints, the Studio and Music surfaces, agent update, and workspace administration.

Troubleshooting

Test Connection passed, but one node family returns 401 with missing_permissions
The key is restricted. ElevenLabs keys can be scoped per product in the dashboard, and the connection test reads the voices list, which most keys can access, so a restricted key passes the test and still fails on products it was not granted, dubbing or Conversational AI for example. Open the key in the ElevenLabs dashboard and grant the missing product, or create an unrestricted key and update the credential on the connector.
Every node returns 401 at once
The key itself is bad: revoked in the dashboard, or pasted with leading or trailing whitespace. The integration sends the xi-api-key header for you, so header formatting is not the cause inside the connector; it only becomes a suspect if you are calling ElevenLabs from a generic HTTP node, where an Authorization Bearer header copied from another AI API fails with a valid key. Create a fresh key and update the credential.
Text to Speech fails with an error about the 5 MB cap
The generated audio was too large for the node's encoded payload cap. Set a lower-bitrate output_format, mp3_22050_32 extends the ceiling to roughly 16 minutes of audio against roughly 4 at the default mp3_44100_128, or split the text across runs. The node fails cleanly with this error rather than returning a truncated blob, so nothing was billed incorrectly downstream of it; the credits for the generation itself were still spent, and ElevenLabs: Get History Audio can re-download the result at no extra generation cost if it fits the cap.
Transcription or dubbing fails because the media could not be fetched
ElevenLabs fetches the media server-side, so the URL has to be reachable from ElevenLabs at the moment the node runs: no login wall, no expired signed link, and a direct media response rather than a player page. Signed URLs are fine, but check the expiry window against how long the flow takes to reach the node. There is no upload alternative on the canvas; if the file only exists locally, put it in object storage or another fetchable location first.
Get Dubbed Audio or the transcript node errors although the dub was created
The job probably has not finished. Dubbing is asynchronous: ElevenLabs: Dub Media from URL returns a dubbing_id immediately while the job runs, so poll ElevenLabs: Get Dubbing until status is dubbed before fetching outputs, and check for a failed status, which carries the error message. If the job is dubbed and ElevenLabs: Get Dubbed Audio still fails, the dubbed media is likely over the 5 MB encoded cap, which full videos always are; download those from the ElevenLabs dashboard and keep the canvas path for short audio dubs and transcripts.
429 responses during a batch run
ElevenLabs limits concurrency per plan rather than requests per minute, so the trigger is how many generations run at the same moment, not how many run per minute. Reduce the flow's parallelism so speech steps run sequentially, or spread the batch over a schedule. The connector surfaces a 429 as a failed step output rather than a crash, so a condition can catch and retry later. Concurrency ceilings rise with the plan tier; the ElevenLabs models documentation lists the current numbers per model family.
Text to Speech rejects the input as too long
Per-request text length is capped per model, and the caps differ widely between model families, so text that one model accepts another refuses. Run ElevenLabs: List Models to see each model's maximum characters alongside its languages, then either switch model_id or split the text into chunks and generate them in sequence. The cap is separate from the 5 MB output cap: one limits what goes in, the other what comes back.
Conversational AI nodes return empty lists or 404
Agent and conversation ids are workspace-scoped, so a 404 usually means an id from a different workspace or one that was deleted. Run ElevenLabs: List Agents first and feed its agent_id values forward, and ElevenLabs: List Conversations to find conversation ids. An empty conversations list on a new agent just means no calls have happened yet. Remember that ElevenLabs: Delete Conversation and ElevenLabs: Delete Agent are permanent: a deleted conversation's transcript, analysis, and audio are gone, which is why both nodes are flagged destructive.

ElevenLabs is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products