Search across all documentation pages
Amazon Transcribe and Amazon Polly sit on opposite sides of the same problem. One turns spoken audio into text. The other turns text into spoken audio. Neither service calls the other, and neither depends on the other's SDK client - but together they form the two ends of almost every voice-driven application built on AWS.
This page is the map before the detail pages: what each service actually does, how their request shapes differ, and where they fit together in a real pipeline.
StartTranscriptionJob, GetTranscriptionJob, StartStreamTranscriptionCommand, SynthesizeSpeech, DescribeVoices.Amazon Transcribe is Amazon's automatic speech recognition (ASR) service. You give it audio - a file in S3, or a live audio stream - and it gives you back text, word by word, with timestamps and confidence scores. The boto3 client is transcribe (@aws-sdk/client-transcribe in TypeScript); the streaming path uses a separate package, @aws-sdk/client-transcribe-streaming.
Amazon Polly is the mirror service for text-to-speech (TTS). You give it a string of text or SSML markup, tell it which voice and audio format you want, and it returns synthesized audio. The client is polly in boto3 and @aws-sdk/client-polly in TypeScript.
Neither service is aware of the other. There is no combined "speech-to-speech" API - if you want to transcribe a call, summarize it, and read the summary back, you call Transcribe, do your own processing on the text, then call Polly. The services are complementary by convention, not by any shared plumbing.
The clearest way to see the difference is to compare the shape of one call from each service.
Transcribe's batch job API takes a reference to audio already in S3 and returns immediately with a job that is still running:
# --- Python (boto3) ---
import boto3
transcribe = boto3.client("transcribe")
transcribe.start_transcription_job(
TranscriptionJobName="call-2026-07-24",
Media={"MediaFileUri": "s3://my-bucket/calls/call.wav"},
MediaFormat="wav",
LanguageCode="en-US",
OutputBucketName="my-bucket",
)
# Returns immediately - the job runs in the background.// --- TypeScript (AWS SDK v3) ---
import { TranscribeClient, StartTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
const transcribe = new TranscribeClient({});
await transcribe.send(new StartTranscriptionJobCommand({
TranscriptionJobName: "call-2026-07-24",
Media: { MediaFileUri: "s3://my-bucket/calls/call.wav" },
MediaFormat: "wav",
LanguageCode: "en-US",
OutputBucketName: "my-bucket",
}));
// Returns immediately - the job runs in the background.You then poll GetTranscriptionJob until TranscriptionJobStatus reaches COMPLETED, at which point the transcript is a JSON document sitting in the S3 bucket you named.
Polly's call looks entirely different in shape, because it is synchronous - the audio comes back in the response body itself:
# --- Python (boto3) ---
import boto3
polly = boto3.client("polly")
response = polly.synthesize_speech(
Text="Your transcript is ready.",
OutputFormat="mp3",
VoiceId="Joanna",
Engine="neural",
)
with open("prompt.mp3", "wb") as f:
f.write(response["AudioStream"].read())// --- TypeScript (AWS SDK v3) ---
import { PollyClient, SynthesizeSpeechCommand } from "@aws-sdk/client-polly";
import { writeFileSync } from "node:fs";
const polly = new PollyClient({});
const response = await polly.send(new SynthesizeSpeechCommand({
Text: "Your transcript is ready.",
OutputFormat: "mp3",
VoiceId: "Joanna",
Engine: "neural",
}));
const bytes = await response.AudioStream?.transformToByteArray();
writeFileSync("prompt.mp3", Buffer.from(bytes ?? []));No job, no polling, no S3 output bucket required - the audio stream is available the moment the call returns.
Transcribe has a second, entirely separate API for cases where a file in S3 is the wrong shape for the problem: live audio. StartStreamTranscriptionCommand (from @aws-sdk/client-transcribe-streaming, or the equivalent bidirectional stream in boto3) accepts a generator of audio chunks and yields transcript results back in near real time. This is a different connection model - a persistent bidirectional stream, not a request/response call - and it is covered in depth on the next page in this section.
The most common real pipeline chains both services around your own application logic in the middle:
Neither service needs to know the other exists; your code is the glue. This also means the two halves scale and fail independently - a Polly outage does not affect your ability to transcribe, and vice versa.
Cost and latency profiles differ meaningfully between the two. Transcribe's batch jobs are billed per second of audio processed and typically complete in a fraction of the audio's own duration, but that is still minutes for a long recording - not something to use in a hard real-time loop. Polly's synchronous call is fast enough for interactive use, but a neural or long-form voice costs more per character than a standard voice, and not every voice is available with every engine in every region.
Choosing between Transcribe's batch and streaming APIs, and between Polly's standard, neural, and long-form engines, both come down to the same question: is the audio already recorded (favor batch, favor whichever engine fits the budget), or does it need to happen live (favor streaming, favor low-latency voice settings)?
transcribe and polly in boto3; @aws-sdk/client-transcribe and @aws-sdk/client-polly in TypeScript) and no shared request shapes.GetTranscriptionJob plus a fetch of the output file.No. Transcribe uses the transcribe boto3 client or @aws-sdk/client-transcribe; streaming transcription uses a further separate package, @aws-sdk/client-transcribe-streaming. Polly uses polly or @aws-sdk/client-polly. All three are independent packages.
No. It starts a background job and returns immediately. You poll GetTranscriptionJob and check TranscriptionJobStatus until it reaches COMPLETED or FAILED, then read the transcript from the S3 location in the response.
Yes. The audio stream comes back in the same response as the request - there is no job, no status to poll, and no required S3 output.
When the audio is live - a phone call in progress, a live captioning feed - rather than a file that already exists. Streaming uses a different, persistent-connection API rather than the file-based job API.
Yes, once your application reads the transcript text out of the completed job's S3 output, you can pass that text (or a summary of it) straight into SynthesizeSpeech - there is no format conversion needed, since Transcribe's transcript is plain text plus metadata.
Not necessarily the same list. Each service publishes its own supported-language table, and coverage for a given language can differ between transcription and synthesis - check both service's documentation for the specific language you need.
Stack versions: This page was written for boto3 1.43.x (Python 3.10+) and the AWS SDK for JavaScript v3 (Node.js 18+).
Reviewed by Chris St. John·Last updated Jul 24, 2026