ElevenLabs MCP Server
The ElevenLabs MCP Server integrates with the ElevenLabs text-to-speech API, enabling you to:
Generate audio from plain text with optional voice settings or from structured scripts supporting multiple voices and actors
Manage voiceover jobs including deleting jobs and retrieving specific audio files
Access voice information by listing all available ElevenLabs voices with metadata
Track voiceover history in a SQLite database, with filtering options by job ID
Use the web-based client (SvelteKit MCP Client) to manage voice generation tasks
Enables text-to-speech audio generation using ElevenLabs' API, supporting multiple voices, script parts with different speakers, audio file management, and voice history tracking.
Provides persistent storage for voice generation history, allowing retrieval and management of past text-to-speech jobs.
Includes a sample SvelteKit MCP Client for text-to-speech conversion, multi-part script management, and audio file playback and downloads.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ElevenLabs MCP Servergenerate audio from this text: Welcome to our new product launch"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ElevenLabs MCP Server
A Model Context Protocol (MCP) server that integrates with ElevenLabs text-to-speech API, featuring both a server component and a sample web-based MCP Client (SvelteKit) for managing voice generation tasks.
Features
Generate audio from text using ElevenLabs API
Support for multiple voices and script parts
SQLite database for persistent history storage
Sample SvelteKit MCP Client for:
Simple text-to-speech conversion
Multi-part script management
Voice history tracking and playback
Audio file downloads
Related MCP server: ElevenLabs MCP Server
Installation
Installing via Smithery
To install ElevenLabs MCP Server for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install elevenlabs-mcp-server --client claudeUsing uvx (recommended)
When using uvx, no specific installation is needed.
Add the following configuration to your MCP settings file (e.g., cline_mcp_settings.json for Claude Desktop):
{
"mcpServers": {
"elevenlabs": {
"command": "uvx",
"args": ["elevenlabs-mcp-server"],
"env": {
"ELEVENLABS_API_KEY": "your-api-key",
"ELEVENLABS_VOICE_ID": "your-voice-id",
"ELEVENLABS_MODEL_ID": "eleven_flash_v2",
"ELEVENLABS_STABILITY": "0.5",
"ELEVENLABS_SIMILARITY_BOOST": "0.75",
"ELEVENLABS_STYLE": "0.1",
"ELEVENLABS_OUTPUT_DIR": "output"
}
}
}
}Development Installation
Clone this repository
Install dependencies:
uv venvCopy
.env.exampleto.envand fill in your ElevenLabs credentials
{
"mcpServers": {
"elevenlabs": {
"command": "uv",
"args": [
"--directory",
"path/to/elevenlabs-mcp-server",
"run",
"elevenlabs-mcp-server"
],
"env": {
"ELEVENLABS_API_KEY": "your-api-key",
"ELEVENLABS_VOICE_ID": "your-voice-id",
"ELEVENLABS_MODEL_ID": "eleven_flash_v2",
"ELEVENLABS_STABILITY": "0.5",
"ELEVENLABS_SIMILARITY_BOOST": "0.75",
"ELEVENLABS_STYLE": "0.1",
"ELEVENLABS_OUTPUT_DIR": "output"
}
}
}
}Using the Sample SvelteKit MCP Client
Navigate to the web UI directory:
cd clients/web-uiInstall dependencies:
pnpm installCopy
.env.exampleto.envand configure as neededRun the web UI:
pnpm devOpen http://localhost:5174 in your browser
Available Tools
generate_audio_simple: Generate audio from plain text using default voice settingsgenerate_audio_script: Generate audio from a structured script with multiple voices and actorsdelete_job: Delete a job by its IDget_audio_file: Get the audio file by its IDlist_voices: List all available voicesget_voiceover_history: Get voiceover job history. Optionally specify a job ID for a specific job.
Available Resources
voiceover://history/{job_id}: Get the audio file by its IDvoiceover://voices: List all available voices
License
This project is licensed under the MIT License - see the LICENSE file for details.
Available Tools
6 toolsdelete_jobB
Delete a voiceover job and its associated files
| Name | Required | Description | Default |
|---|---|---|---|
| job_id | Yes | ID of the job to delete |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool deletes a job and associated files, which implies a destructive, irreversible operation. However, it lacks details about permissions needed, confirmation prompts, error handling, or what happens if the job doesn't exist.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any unnecessary words. It's appropriately sized and front-loaded with the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive operation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after deletion (e.g., confirmation message, error responses), nor does it address important behavioral aspects like permissions or irreversible consequences.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'job_id' clearly documented. The description doesn't add any additional parameter semantics beyond what the schema already provides, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Delete') and target resource ('a voiceover job and its associated files'), making the purpose unambiguous. It distinguishes this destructive operation from sibling tools that are primarily about generation, retrieval, or listing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives or any prerequisites. While it's clear this is for deletion, there's no mention of when deletion is appropriate versus other operations like retrieving or listing jobs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_audio_scriptB
Generate audio from a structured script with multiple voices and actors. Accepts either: 1. Plain text string 2. JSON string with format: { "script": [ { "text": "Text to speak", "voice_id": "optional-voice-id", "actor": "optional-actor-name" }, ... ] }
| Name | Required | Description | Default |
|---|---|---|---|
| script | Yes | JSON string containing script array or plain text. For JSON format, provide an object with a 'script' array containing objects with 'text' (required), 'voice_id' (optional), and 'actor' (optional) fields. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It explains the input format but doesn't describe what happens after submission: whether this is an async operation, how to retrieve results, expected output format, error conditions, rate limits, or authentication requirements. For a tool that likely creates audio files, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose. The format explanation is necessary but could be slightly more streamlined. Every sentence serves a purpose, though the JSON example takes significant space that might be better in schema examples.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a generation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (audio file URL? job ID? error messages?), how to handle the output, or any post-generation steps. For a tool that presumably creates audio content, this leaves the agent without crucial information about result handling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents the single parameter. The description adds valuable context by explaining the two acceptable formats (plain text vs. JSON) and providing a concrete JSON structure example. This goes beyond what the schema provides, though it could elaborate more on when to use each format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate audio from a structured script with multiple voices and actors.' This specifies the verb ('generate audio'), resource ('structured script'), and key capabilities ('multiple voices and actors'). However, it doesn't explicitly differentiate from sibling tools like 'generate_audio_simple', which likely has a simpler interface.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'generate_audio_simple' or explain scenarios where this more complex script format is preferred over simpler options. There's no context about prerequisites, limitations, or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_audio_simpleC
Generate audio from plain text using default voice settings
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | Plain text to convert to audio | |
| voice_id | No | Optional voice ID to use for generation |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'generate[s] audio' but lacks details on permissions, rate limits, output format, or side effects. While it implies a creation operation, it doesn't clarify if this is a one-time generation or if audio is saved/stored, leaving significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence contributes to understanding the tool's function, making it appropriately sized and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of an audio generation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the output is (e.g., file format, URL, or data), error conditions, or behavioral traits like latency or resource usage, leaving the agent with insufficient context for reliable use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters ('text' and 'voice_id') adequately. The description adds minimal value by implying 'plain text' for the 'text' parameter and 'default voice settings' for 'voice_id', but doesn't provide additional syntax or format details beyond what the schema offers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'generate' and resource 'audio from plain text', specifying the action and input type. It distinguishes from siblings like 'generate_audio_script' by emphasizing 'simple' and 'default voice settings', though it doesn't explicitly contrast with all siblings like 'get_audio_file' or 'list_voices'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions 'default voice settings' but doesn't specify when to choose this over 'generate_audio_script' or other siblings, nor does it indicate prerequisites or exclusions for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_audio_fileC
Get the audio file content for a specific job
| Name | Required | Description | Default |
|---|---|---|---|
| job_id | Yes | ID of the job to get audio file for |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but doesn't describe what 'Get' entails—whether it returns raw audio data, a file URL, or a stream; any authentication or permission requirements; rate limits; or error conditions (e.g., if the job doesn't exist or isn't ready). This leaves significant gaps for a tool that likely involves data retrieval.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse. Every part of the sentence contributes to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of retrieving audio content (likely involving binary data or file handling), no annotations, and no output schema, the description is insufficient. It doesn't explain the return type (e.g., audio format, size limits), error handling, or behavioral details like whether it's idempotent or has side effects. This leaves the agent with incomplete information for proper invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'job_id' fully documented in the schema. The description adds no additional meaning beyond implying the job must exist and have an associated audio file, but it doesn't specify format, constraints, or examples. This meets the baseline of 3 since the schema handles the parameter documentation adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('audio file content') with a specific target ('for a specific job'). It distinguishes from siblings like 'list_voices' or 'get_voiceover_history' by focusing on retrieving actual audio content rather than metadata or lists. However, it doesn't explicitly differentiate from potential similar tools like 'generate_audio_simple' beyond the 'get' vs 'generate' distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a completed job), exclusions (e.g., not for in-progress jobs), or comparisons to siblings like 'get_voiceover_history' (which might retrieve metadata vs content). Usage is implied by the purpose but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_voiceover_historyB
Get voiceover job history. Optionally specify a job ID for a specific job.
| Name | Required | Description | Default |
|---|---|---|---|
| job_id | No | Optional job ID to get details for a specific job |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves history but doesn't describe return format, pagination, error handling, authentication needs, rate limits, or whether it's read-only. The description is minimal and lacks essential behavioral context for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two sentences that are front-loaded and waste-free. The first sentence states the core purpose, and the second clarifies the optional parameter usage, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a simple input schema, the description is incomplete. It doesn't explain what 'voiceover job history' entails (e.g., list of jobs, statuses, metadata), return values, or behavioral traits like safety or performance. For a tool with minimal structured data, the description should provide more context to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the parameter 'job_id' documented as 'Optional job ID to get details for a specific job'. The description adds minimal value by restating this as 'Optionally specify a job ID for a specific job', which doesn't provide additional semantics beyond the schema. Baseline 3 is appropriate given high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Get voiceover job history' with the verb 'Get' and resource 'voiceover job history'. It distinguishes between retrieving general history versus specific job details, though it doesn't explicitly differentiate from sibling tools like 'get_audio_file' or 'list_voices'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage guidance by mentioning the optional job ID parameter for retrieving a specific job, which suggests when to use this tool versus alternatives. However, it lacks explicit guidance on when to use this tool over siblings like 'get_audio_file' or 'list_voices', and no exclusions or prerequisites are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_voicesB
Get a list of all available ElevenLabs voices with metadata
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states what the tool does but doesn't describe traits like whether it's read-only (implied by 'Get'), rate limits, authentication needs, error conditions, or what 'metadata' includes. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get a list...') with no wasted words. Every part earns its place by specifying the resource and scope ('all available ElevenLabs voices with metadata').
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It explains what the tool does but lacks details on behavior, output format, or usage context. For a read operation with no structured output documentation, more completeness would help the agent understand what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description adds no parameter information beyond this, which is appropriate. Baseline for 0 parameters is 4, as no compensation is needed for schema gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('list of all available ElevenLabs voices with metadata'), making the purpose specific and understandable. It doesn't explicitly distinguish from sibling tools like 'get_voiceover_history' or 'get_audio_file', but the focus on voices rather than audio files or history provides implicit differentiation. A 5 would require explicit sibling comparison.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, timing considerations, or compare it to sibling tools like 'get_voiceover_history' for historical data or 'generate_audio_simple' for voice selection. The agent must infer usage from the purpose alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
6 tool updates
v1.0.0- First observed
delete_job - First observed
generate_audio_script - First observed
generate_audio_simple - First observed
get_audio_file - First observed
get_voiceover_history - First observed
list_voices
TDQS
Each tool has a clearly distinct purpose with no ambiguity. delete_job removes jobs, generate_audio_script creates multi-voice audio from structured input, generate_audio_simple creates basic audio, get_audio_file retrieves audio content, get_voiceover_history accesses job history, and list_voices lists available voices. The two generation tools are clearly differentiated by complexity level.
All tools follow a consistent verb_noun pattern throughout: delete_job, generate_audio_script, generate_audio_simple, get_audio_file, get_voiceover_history, list_voices. The naming convention is perfectly uniform with clear action-object relationships and no mixing of styles.
Six tools is an ideal number for this audio generation domain. It provides complete coverage of core workflows (generation, retrieval, management, discovery) without being overwhelming. Each tool earns its place with clear utility in the voiceover job lifecycle.
The toolset provides complete CRUD/lifecycle coverage for ElevenLabs voiceover operations: create (two generation tools), read (get_audio_file, get_voiceover_history, list_voices), delete (delete_job). There are no obvious gaps - agents can create audio, retrieve results, manage jobs, and discover available voices.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
ElevenLabs in natural language: generate speech in any language, create and manage voices, compose m
AI voice generation: text-to-speech and voice cloning from any MCP client.
- JellypodOAuthcom.jellypod
Create, import, and publish Jellypod podcast episodes from your AI assistant.
Hosted pay-per-use TTS: 54 neural voices, 9 languages incl. Brazilian Portuguese. $10 free credits.
Related MCP Servers
- AlicenseAqualityNot gradedmaintenanceEnables interaction with ElevenLabs Text-to-Speech and audio processing APIs. Supports speech generation, voice cloning, audio transcription, and sound effect creation through natural language.24-
- AlicenseAqualityFmaintenanceEnables text-to-speech conversion using ElevenLabs API with voice management, streaming support, and multiple models.51MIT
- AlicenseAqualityDmaintenanceEnables streaming text-to-speech generation using ElevenLabs with real-time audio playback and voice listing.230MIT
- FlicenseNot gradedqualityDmaintenanceProvides tools for generating speech from text using the ElevenLabs API, including voice listing, text-to-speech conversion, and quota checking.-
Appeared in Searches
- Automating Workflow for File Processing and Communication
- A workflow for processing and sharing meeting-related materials
- A platform providing TTS (Text-to-Speech) capabilities
- Talking to Claude desktop in Russian using map-server connection
- A Minecraft client for regular internet users, not developers or experts
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/mamertofabian/elevenlabs-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server