Grok TTS: Text to Speech That Takes Stage Directions

A script isn't just words. Look at any page an actor gets handed and you'll find the other half of the job written in the margins: beat, softer here, laughs, slows down on the last line. Most text to speech throws that half away. You paste in clean sentences, you get clean sentences back, and the joke lands with the warmth of a train platform announcement.

So people hack around it. Commas to fake a pause, one line split into three requests, regeneration until the read has some life. That's not directing. It's hoping.

Grok TTS from xAI takes a more interesting route. It lets you write the margin notes straight into the text. A pause is a tag. A laugh is a tag. A whispered aside is a phrase wrapped in a tag. The script and the stage directions finally travel together, and that changes how you write for a voice.

What Grok TTS Actually Is

Grok TTS is xAI's standalone text to speech model. xAI announced it alongside Grok Speech to Text on April 17, 2026, describing it as "fast, natural, and expressive voices with Speech Tags" and saying both APIs are built on the same stack that powers Grok Voice, Tesla vehicles and Starlink customer support. You can read the official announcement from xAI for the full framing.

One thing to keep straight: Grok TTS isn't Grok Voice. Grok Voice is xAI's speech-to-speech model for live conversation, where audio goes in and audio comes out. Grok TTS is the one that takes text and gives you a finished audio file. That's the model running on each::labs, on the Grok TTS family page, next to the rest of the xAI models on each::labs.

The each::labs request is small and readable. A text field that takes up to 15,000 characters, a voice, a language, an output format, a sample rate and an MP3 bit rate. That's it. Everything expressive lives inside the text itself, which is exactly the design choice worth paying attention to.

Grok Text to Speech, With Stage Directions Built In

Most voice models give you expression as a setting. Pick an emotion from a dropdown, slide a speed control, maybe write a style instruction in a separate field. The trouble is that a setting applies to the whole clip. Real speech changes mood mid-sentence. Someone can be calm, then amused, then quiet, all inside ten seconds.

Grok text to speech handles that by putting the control where the change happens. Here's the kind of line xAI uses in its own docs to show the idea:

So I walked in and [pause] there it was. [laugh] I honestly could not believe it!

Without the tags it's flat. With them you can already hear the timing: the beat before the reveal, the laugh that breaks the sentence. You didn't describe a mood. You marked the moments, and the performance became part of the copy.

Inline Tags Are Sounds, Wrapping Tags Are Delivery

The each::labs schema lists two kinds of tag, and they do different jobs. Keep them straight and your scripts get much easier to write.

Inline tags are single events. They drop a sound or a silence into a specific spot, and the speech carries on after it. These are the ones Grok TTS accepts:

[pause] [long-pause]
[laugh] [chuckle] [giggle] [cry]
[tsk] [tongue-click] [lip-smack]
[breath] [inhale] [exhale] [sigh]
[hum-tune]

Wrapping tags change how a stretch of speech is delivered. They open and close around a phrase, like markup around a word in a document, and everything inside takes on the effect:

<whisper> <soft> <loud>
<slow> <fast>
<higher-pitch> <lower-pitch>
<sing-song> <singing> <laugh-speak>
<emphasis>
<build-intensity> <decrease-intensity>

Inline tags are things a person does: a sigh, a breath, a click of the tongue. Wrapping tags are the way a person says something: quietly, quickly, with a rising edge. A good script uses both, and it uses them sparingly.

xAI's docs show wrapping tags nesting, too. A bedtime sign-off can be slow and soft at once:

<slow><soft>Goodnight, sleep well.</soft></slow>

And a secret can sit inside an otherwise normal line:

I need to tell you something. <whisper>It is a secret.</whisper> Pretty cool, right?

Five Voices, Picked by the Job

Grok TTS gives you five voices on each::labs, and the schema describes each one by what it's for. That's useful, because a voice is a casting decision, not a sound preference.

Eve is the default, described as energetic and upbeat, built for demos and announcements. Ara is warm and friendly, the one the schema points at conversational interfaces. Rex is confident and clear, for business content and tutorials. Sal is smooth and balanced, the generalist for varied content. Leo is authoritative and strong, aimed at instructional material.

Five sounds like a short list until you notice what it removes: twenty minutes of auditioning. A product launch video gets Eve. A support assistant that has to sound patient at the fortieth question of the day gets Ara. A compliance walkthrough gets Leo, because nobody skips a module read by someone who sounds like they mean it.

The tags matter more here than they would with a big voice library. With a smaller cast, range comes from direction, not from swapping actors. Rex reading a tutorial plainly and Rex with a dry [chuckle] after a known gotcha are two different experiences, and you only had to change one word in the script.

Twenty Languages, One Required Field

Language is a required field in the each::labs request, so you'll set it on every call. You can pass auto and let the model detect it, or pick from the listed codes: English, Bengali, Chinese, French, German, Hindi, Indonesian, Italian, Japanese, Korean, Russian, Turkish, Vietnamese, three Arabic variants (Egypt, Saudi Arabia, UAE), Brazilian and European Portuguese, and Mexican and Castilian Spanish.

Those regional splits aren't decoration. A Brazilian audience hears European Portuguese as foreign within a sentence, and the same goes for Spanish across the Atlantic. If you know your listener, name the variant instead of relying on detection. Save auto for genuinely mixed inputs, like user-submitted text you can't predict.

Pick the Output Format Before You Write the Script

This is the part people leave until last, and it should come first. Where the audio ends up decides how you should write it.

The each::labs schema offers five codecs. MP3 is the default for general use. WAV is lossless and meant for editing and post-production. PCM is raw 16-bit audio for processing pipelines. Mu-law and A-law are the G.711 telephony codecs. Sample rate runs from 8,000 Hz for narrowband telephony up to 48,000 Hz studio grade, with 24,000 Hz as the default, and MP3 bit rate goes from 32 kbps to 192 kbps, defaulting to 128 kbps.

Those telephony options say a lot about who this model is for. If you're building a phone agent or an IVR flow, you can ask for mu-law at 8,000 Hz and drop the result straight into the call stack without a conversion step. And if you know the audio is going down a phone line, write for it: shorter sentences, more [pause] tags, fewer whispers. A whisper at 8 kHz over a mobile connection is just a hiss.

Headed into a video edit or a podcast? Ask for WAV at 44,100 or 48,000 Hz so your editor has room to work.

Write Scripts Like a Director, Not a Typesetter

The tags are powerful, which is exactly why people overuse them. xAI's own guidance is short and good: place inline tags where the expression would naturally occur, wrap complete phrases rather than single words, and lean on punctuation, since combining tags with punctuation produces more natural results than stacking tags.

Here's what that looks like for a product walkthrough read by Rex:

Okay, last step. [breath] Open settings, find the export tab, and hit save. <emphasis>Not publish.</emphasis> Save. [chuckle] Everyone gets that wrong the first time.

Three tags in four sentences, each one doing a specific job. The breath resets the pace before an instruction. The emphasis lands the one thing the viewer must not miss. The chuckle makes the mistake feel normal instead of embarrassing.

Overdo it (a laugh after every sentence, emphasis around half the paragraph) and every marked moment competes with the others. If everything is emphasized, nothing is.

A narration example, for a story intro read by Sal:

The lighthouse had been dark for eleven years. [long-pause] <soft>Then, one night in October,</soft> <build-intensity>the lamp turned on by itself.</build-intensity>

Notice the long pause sits at a paragraph break a human narrator would also take, and the wrapping tags cover full phrases. That's the whole method. Write the line, read it aloud yourself, and mark only the places where your own voice changed.

How Grok TTS Compares With Other Voices on each::labs

Grok TTS isn't the only expressive voice model you can run on each::labs, and the right pick depends on how you want to steer the performance. The text to voice models on each::labs take quite different approaches.

MiniMax Speech 2.8 HD also supports inline cues, with timed pause markers and interjections like laughs, sighs and coughs, and it adds an emotion setting that colors the whole request rather than a single phrase. Gemini 3.1 Flash TTS from Google steers delivery with a natural-language style instruction in its own field and supports two named speakers in one request, which makes it a natural fit for dialogue. Inworld TTS 1.5 gives you a large voice roster and speaking rate and temperature controls, with requests of up to 2,000 characters.

Grok TTS sits in a clear spot among them: the richest in-line direction of the four, with both event tags and delivery wrappers, and room for 15,000 characters of script in one request. If your copy changes mood inside a paragraph, it's the one built for that. If you'd rather describe a style once and let the model run, Gemini's prompt field might suit you better. Our ranking of the best AI text to speech models in 2026 breaks the field down by job, and the Inworld TTS 1.5 guide goes deeper on that model.

xAI also ships xAI Speech to Text on each::labs, so you can transcribe a recording, rewrite the text with tags, and read it back with Grok TTS without leaving the same provider.

Running Grok TTS on each::labs

The call follows the same shape as every other model on each::labs. Point it at the Grok TTS slug, pass your tagged text, pick a voice and a language:

curl -X POST \
  -H "Authorization: Bearer $EACHLABS_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "xai-grok-tts-text-to-speech",
    "input": {
      "text": "Welcome back. [pause] <emphasis>This</emphasis> is the update you asked for. [chuckle]",
      "voice_id": "eve",
      "language": "en",
      "output_format": "wav",
      "sample_rate": 48000
    }
  }' \
  https://api.eachlabs.ai/v1/prediction

You get a prediction back, which you poll or receive by webhook. Swap the voice to ara for an assistant, set output_format to mulaw and sample_rate to 8000 for a phone line, or set language to tr for a Turkish build. Everything else stays the same.

If you want this inside a bigger pipeline (a script written by a language model, voiced, then laid under a generated video), each::labs AI flows let you chain those steps without gluing the calls together yourself. And if you need a specific person's voice instead of a stock one, our XTTS v2 voice cloning post covers that route.

The words were never the hard part of a voiceover. The margin notes were. Grok TTS finally lets you write them down.

Frequently Asked Questions

What is Grok text to speech used for?

Anywhere a read needs timing and personality, not just correct pronunciation. xAI positions it for voice agents, accessibility tools, podcasts and interactive audio. On each::labs, the telephony codecs make it practical for phone agents, and WAV at 48 kHz makes it practical for video and podcast production.

How do Grok TTS speech tags work?

There are two families. Inline tags in square brackets, like [pause] or [sigh], insert a single event at one spot. Wrapping tags in angle brackets, like <whisper> or <slow>, change the delivery of every word between the opening and closing tag. You can nest wrapping tags, and xAI recommends wrapping whole phrases rather than single words.

Is Grok TTS the same as Grok Voice?

No. Grok Voice is xAI's speech-to-speech model for live, two-way conversation. Grok TTS turns written text into an audio file, and it's the model available on each::labs today. The tags you write for Grok TTS are part of the text you send, so the whole performance is in your script.

Which languages and voices does Grok TTS support?

Five voices (Eve, Ara, Rex, Sal and Leo) and twenty listed language codes plus auto-detection, including Turkish, Japanese, Hindi, three Arabic variants and regional Portuguese and Spanish. Language is required on each::labs, so pass auto when you can't predict the input.