Originally published at hafiz.dev

Taylor Otwell dropped a one-liner on X yesterday that stopped me mid-scroll:

$audio = Str::of('Hello, Laravel')->toAudio();

That's it. One method call and your string becomes audio. No external SDK wiring, no Guzzle calls, no API response parsing. Just ->toAudio() on a Stringable, the same way you'd call ->upper() or ->slug().

If you've been following the Laravel AI SDK through Part 1 (building a smart assistant) and Part 2 (RAG-powered support bot), you already know how text generation and tool calling work. But there's a whole side of the SDK that most developers haven't touched yet: audio. Text-to-speech generation, voice customization, speech-to-text transcription, queued processing, and testing support are all built in.

Let's build with it.

What You'll Build

By the end of this tutorial, you'll have a Laravel app that can:

• Convert any text to natural-sounding audio and store it
• Choose between male, female, or specific voice IDs
• Coach the AI on how the audio should sound (tone, pace, emotion)
• Transcribe uploaded audio files back to text (with speaker detection)
• Queue audio generation for background processing
• Test everything without hitting a single API

We'll start simple and build up. You don't need any AI experience to follow along.

Setup

If you already have the AI SDK installed from a previous tutorial, skip to the next section. Otherwise:

composer require laravel/ai

php artisan vendor:publish --provider="Laravel\Ai\AiServiceProvider"

php artisan migrate

Add your provider credentials to .env. For audio, you need at least one of these:

OPENAI_API_KEY=your-openai-key
ELEVENLABS_API_KEY=your-elevenlabs-key

OpenAI supports both text-to-speech and speech-to-text. ElevenLabs supports both as well, plus Mistral handles transcription. The full provider matrix from the official docs:

That's it for setup. Let's generate some audio.

Your First Audio Generation

The Audio facade gives you a clean, fluent API:

use Laravel\Ai\Audio;

$audio = Audio::of('Your order has been shipped and will arrive by Thursday.')->generate();

The $audio object holds the raw audio content. You can cast it to a string to get the bytes, or store it directly:

// Store on your default disk
$audio->store();

// Store with a specific path and filename
$audio->storeAs('audio', 'order-confirmation.mp3');

// Store on the public disk
$audio->storePublicly();

Want to serve it directly from a controller? Return it as a response:

Route::get('/audio/preview', function () {
    $audio = Audio::of('Welcome to our support line.')->generate();

    return response((string) $audio)
        ->header('Content-Type', 'audio/mpeg');
});

That's a working audio endpoint in five lines. And if you just need a quick one-liner somewhere in your code, the Stringable integration is even shorter:

use Illuminate\Support\Str;

$audio = Str::of('Hello, Laravel')->toAudio();

This is what Taylor tweeted about. The AI SDK registers toAudio() as a method on the Stringable class, so you can chain it alongside ->replace(), ->trim(), or any other string method. It's the same pattern as ->toEmbeddings() for vector search.

Choosing a Voice

The SDK gives you three ways to control the voice:

// Quick gender selection
$audio = Audio::of('Welcome back!')->female()->generate();
$audio = Audio::of('Your package is ready.')->male()->generate();

// Specific voice by ID or name
$audio = Audio::of('Breaking news: Laravel 14 announced.')
    ->voice('alloy')
    ->generate();

OpenAI offers 11+ voices including alloy, ash, coral, echo, fable, nova, onyx, sage, shimmer, and verse. Each has a distinct character. alloy is neutral and balanced, good for most use cases. nova sounds more expressive and warm. onyx has a deeper, more authoritative tone. I'd suggest generating a short sample with each voice before committing to one for production. The difference is noticeable.

If you're using ElevenLabs, you can pass any voice ID from your account, including custom cloned voices. ElevenLabs generally produces more natural-sounding output than OpenAI for longer narration, but OpenAI is faster and cheaper for short clips. The choice depends on what you're building. Quick notifications? OpenAI. Full blog post narrations or product demos? ElevenLabs is probably worth the extra cost.

Style Instructions

This is where things get interesting. The instructions method lets you coach the AI on how the audio should sound:

$audio = Audio::of('Ahoy! Your treasure has arrived!')
    ->female()
    ->instructions('Speak like a friendly pirate captain')
    ->generate();

$audio = Audio::of('We regret to inform you that your account has been suspended.')
    ->male()
    ->instructions('Professional and empathetic, slow pace')
    ->generate();

Think of instructions as a system prompt for voice. You can control tone, pace, emotion, accent style, and delivery. It won't always nail it perfectly (this depends on the provider), but for most use cases it makes a noticeable difference. Try things like "cheerful and upbeat", "calm and measured", or "urgent, like a news anchor".

Five Practical Use Cases

Before we move on, here are patterns I think are worth building:

1. Blog post audio versions. Generate an audio file when a post is published. Store it alongside the post and embed an HTML5 audio player. Accessibility win, and it keeps readers on the page longer.

// In your Post observer or event listener
$audio = Audio::of($post->plain_text_content)
    ->female()
    ->instructions('Conversational and clear, like a podcast host')
    ->generate();

$audio->storeAs('posts', "post-{$post->id}.mp3");

2. Order confirmation voice messages. E-commerce apps can generate a short audio clip summarizing the order and attach it to the confirmation email or display it on the "thank you" page.

3. In-app notifications with voice. Instead of (or alongside) push notifications, generate a short spoken version. Useful for accessibility or for apps used in environments where reading a screen isn't practical.

4. Interactive voice responses. Build a simple IVR system. Use the AI SDK for TTS on the outbound side and transcription on the inbound side. No Twilio SDK needed for the voice generation part.

5. Language learning tools. Generate pronunciation examples dynamically. Pass different instructions for different accents or speaking speeds.

Speech-to-Text Transcription

The SDK handles the reverse direction too. If you have an audio file, turn it into text:

use Laravel\Ai\Transcription;

// From a file on disk
$text = Transcription::fromStorage('recordings/meeting.mp3')->generate();

echo (string) $text; // "Alright team, let's review the Q2 numbers..."

You can also transcribe from a raw file path:

$text = Transcription::fromPath('/tmp/uploaded-audio.webm', 'audio/webm')->generate();

This pairs naturally with file uploads. A typical controller might look like this:

public function transcribe(Request $request)
{
    $request->validate([
        'audio' => 'required|file|mimes:mp3,wav,webm',
    ]);

    $path = $request->file('audio')->store('temp');

    $text = Transcription::fromPath(
        Storage::path($path),
        $request->file('audio')->getMimeType()
    )->generate();

    Storage::delete($path);

    return response()->json(['text' => (string) $text]);
}

That's a complete speech-to-text endpoint. Twenty lines, including validation and cleanup. Compare that to wiring up the OpenAI API manually with Guzzle, handling multipart uploads, parsing JSON responses, and managing error states. The SDK handles all of that behind a single generate() call.

One thing to watch for: the transcription providers have file size limits. OpenAI's Whisper accepts files up to 25MB. For longer recordings, you'll need to split the audio into chunks first. FFmpeg handles this well, and you can use Laravel's Process facade to run it:

use Illuminate\Support\Facades\Process;

Process::run("ffmpeg -i input.mp3 -f segment -segment_time 300 -c copy chunk_%03d.mp3");

That splits a recording into 5-minute chunks. Transcribe each one and concatenate the results.

Speaker Diarization

For meeting recordings or multi-speaker audio, the SDK supports speaker diarization, which identifies who spoke when. This is useful for automated meeting notes, call center analytics, or podcast transcription workflows.

Not all providers handle diarization the same way. OpenAI's newer GPT-4o Transcribe model supports it natively, but the legacy Whisper model does not. ElevenLabs supports it as well. Check the official AI SDK documentation for the exact method chain and provider requirements, as this feature is still evolving across providers.

Queued Audio Generation

Audio generation takes time, especially for longer text. You don't want users staring at a spinner while their blog post gets narrated. Queue it:

Audio::of($post->plain_text_content)
    ->female()
    ->instructions('Conversational, like a podcast')
    ->generateQueued();

The SDK dispatches a job to your queue system. If you need to do something with the audio after it generates (store it, notify the user), chain a callback:

Audio::of($post->plain_text_content)
    ->female()
    ->generateQueued()
    ->then(function ($audio) use ($post) {
        $audio->storeAs('posts', "post-{$post->id}.mp3");

        $post->update(['has_audio' => true]);
    });

This is the pattern I'd use for blog post narration. Publish the post, dispatch the audio job, and update the post record when the file is ready. The reader sees the audio player appear once it's processed.

Switching Providers

By default, the SDK uses whatever provider you've configured in config/ai.php. But you can switch providers per request:

use Laravel\Ai\Enums\Lab;

// Use ElevenLabs for higher-quality voice
$audio = Audio::of('Premium audio content')
    ->generate(Lab::ElevenLabs);

// Use OpenAI for faster, cheaper generation
$audio = Audio::of('Quick notification')
    ->generate(Lab::OpenAI);

If you've read the AI SDK overview, you'll recognize this pattern. It's the same Lab enum used for text generation. One SDK, one API, multiple providers.

Testing Without API Calls

You don't want your test suite hitting OpenAI's API every time it runs. The SDK has built-in fakes:

use Laravel\Ai\Audio;
use Laravel\Ai\Transcription;

it('generates audio for a new post', function () {
    Audio::fake();

    $post = Post::factory()->create();

    // Your code that generates audio...

    Audio::assertGenerated(function ($audio) {
        return str_contains($audio->text, 'order has been shipped');
    });
});

it('transcribes uploaded audio', function () {
    Transcription::fake();

    // Your code that transcribes...

    Transcription::assertGenerated();
});

Audio::fake() prevents any HTTP requests and lets you assert that generation happened with the right inputs. Same pattern as Http::fake(), Mail::fake(), or Queue::fake(). If you've tested anything in Laravel before, this is familiar.

Production Considerations

A few things I'd think about before shipping audio features to real users.

Cache aggressively. If the same text generates the same audio, store the result and serve it from disk next time. Don't regenerate audio for content that hasn't changed. For blog posts, generate once on publish and serve the stored file forever. Invalidate only when the content is updated.

Handle failures gracefully. API calls fail. Rate limits hit. Provider outages happen. Wrap your audio generation in try/catch blocks and make sure the user experience degrades gracefully when audio isn't available. A missing audio player is better than a 500 error.

try {
    $audio = Audio::of($text)->generate();
    $audio->storeAs('audio', "post-{$id}.mp3");
} catch (\Throwable $e) {
    Log::warning("Audio generation failed for post {$id}", [
        'error' => $e->getMessage(),
    ]);
    // Continue without audio - the post still works
}

Set appropriate timeouts. Longer text takes longer to generate. If you're narrating a 2,000-word blog post, the API might need 15-20 seconds. That's too long for a synchronous request. Use queued generation for anything over a paragraph or two.

Monitor your spending. Both OpenAI and ElevenLabs charge per character. If you have a webhook or background job that generates audio, a bug could run up a surprising bill fast. Set up billing alerts on your provider accounts and consider adding a character count guard in your code.

Costs and Rate Limits

A quick note on pricing, because this comes up every time someone talks about AI in production. As of right now, OpenAI's TTS costs roughly $15 per million characters. For context, a 2,000-word blog post is about 10,000 characters. That's $0.15 per post narrated. ElevenLabs offers 10,000 characters per month on their free tier, with paid plans starting around $5/month for higher quotas and premium voices.

For transcription, OpenAI Whisper costs about $0.006 per minute of audio. A 30-minute meeting transcript runs roughly $0.18.

These costs are low enough for most production use cases, but cache or store your generated audio. Don't regenerate the same content repeatedly.

FAQ

Can I use this without the AI SDK's agent features?

Yes. The Audio and Transcription facades are completely standalone. You don't need to create agents, define tools, or set up conversations. Just composer require laravel/ai, add your API key, and call Audio::of('text')->generate().

Which providers support the ->toAudio() Stringable method?

The ->toAudio() method uses whatever default provider you've configured for audio in config/ai.php. You can set this to OpenAI or ElevenLabs. The Stringable shortcut doesn't accept provider arguments directly, so configure your preferred provider in the config file.

Does this work with Laravel 12 or only Laravel 13?

The AI SDK works with both Laravel 12 and 13. The ->toAudio() Stringable integration, the Audio facade, and the Transcription class are available in the current stable version of the SDK regardless of which Laravel version you're running.

Can I generate audio in languages other than English?

Yes. Pass your text in any language the provider supports. OpenAI's TTS handles dozens of languages automatically based on the input text. For ElevenLabs, you may need to select a voice trained for your target language, or use their multilingual model.

How long can the input text be?

OpenAI's TTS endpoint accepts up to 4,096 characters per request. For longer content (like a full blog post), you'll need to split the text into chunks and generate separate audio files. Concatenation is straightforward with FFmpeg.

What's Next

Text generation, tool calling, RAG, and now audio. The AI SDK covers a lot of ground from a single composer require. If you haven't tried the text features yet, start with Part 1 and Part 2. If you're already using the SDK and want to explore what Claude Opus 4.7 changes for your AI setup, that post covers the breaking changes and token adjustments you need to know about.

If you're building voice features into a Laravel app and need help with architecture, queue strategies, or production scaling, get in touch.