# DeepSeek OCR, ASR and TTS APIs: can one vendor replace three?

URL: https://infro.io/blog/deepseek-ocr-asr-and-tts-apis-can-one-vendor-replace-three
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-15
Last modified: 2026-11-15
Last reviewed: 2026-11-15 (next review due 2026-12-15)
Topic: Evaluation and models
Format: Comparison

> DeepSeek's new endpoints are cheap per unit on its published rates, but their documented limits (120-second audio, left channel only, two voices, raw OCR text) make them a candidate for specific routes, not a blanket replacement. Test each modality on your own data and keep the incumbent as a fallback. [^deepseek-pricing]

Key takeaways:
- DeepSeek lists OCR at $0.225 per 1,000 pages, ASR at $0.116 per audio hour and TTS at $0.45 per 10,000 characters, with a limited-time lower rate on the two speech endpoints.
- The documented limits decide fit before price does: ASR takes 120 seconds per request and reads only the left channel, TTS offers two voices, and OCR returns raw page text with coordinate tokens.
- Judge each modality on its own golden set and cost per accepted output, not per billed unit.
- Voice ids are vendor-specific, so a TTS fallback changes the voice your users hear; OCR and ASR fall back more easily but return different shapes.
- A 200 response can still carry an OCR error object, so retry rules keyed only on status codes will miss it.

## What DeepSeek opened on 13 November

On 13 November 2026 DeepSeek released what it calls the full suite of application APIs: web search, file input, URL reading, safety checks, and standalone Search, Fetch, OCR, ASR and TTS endpoints.[1] The standalone endpoints live under `/v1/tools/` on `api.deepseek.com`, separate from the chat models.[2][3][4] The change log states the purpose: the underlying capabilities behind the DeepSeek App, including voice, are now open to developers.[5]

That framing matters for evaluation. These are the app's building blocks exposed as tools, and DeepSeek's own example for ASR and TTS is a chatbot with voice input and read-aloud.[6] Teams running call transcription, long-form narration or document-extraction pipelines have different needs. This article does not rank accuracy, because DeepSeek's pages publish no benchmarks for these three endpoints. It covers what the documents state: limits, shapes, billing and failure behavior. Then it gives a test plan you can run on your own files.

## Per-unit rates side by side

DeepSeek bills each endpoint in a different unit, which is the first normalization problem. OCR is per page, ASR per second of audio (listed per hour), and TTS per character (listed per 10,000).[7]

| Endpoint | Billing unit | List price | Limited-time price | Derived per unit (list) |
| --- | --- | --- | --- | --- |
| OCR and file parsing | 1,000 pages | $0.225 | not listed | $0.000225 per page |
| ASR | 1 hour of audio | $0.116 | $0.058 | about $0.00193 per minute |
| TTS | 10,000 characters | $0.45 | $0.225 | $0.045 per 1,000 characters |

Table: DeepSeek's published rates, read on 15 November 2026; the last column is arithmetic on the list price. These are what DeepSeek bills, not an INFRO charge.[7]

Three details change the arithmetic. OCR bills only pages recognized successfully, and a failed or timed-out recognition is not billed, but a client disconnect does not cancel the job: once the file is received it runs to the end and is billed if it completes.[2] ASR bills by duration to the second, and a fraction of a second counts as one second.[3] TTS counts a Chinese character as 2 and any other character, including spaces and digits, as 1.[4] A Chinese-language narration workload therefore costs double per visible character.

Token pricing with peak and off-peak hours applies to the chat models; the pricing page states those peak hours for model tokens, and the OCR and speech rows carry no peak or off-peak split.[7]

> **Example: Illustrative monthly volumes**
> The volumes below are made up to show the arithmetic. At 1,000,000 pages a month, OCR is 1,000 units of $0.225, or $225. At 10,000 audio hours, ASR is $1,160 at the list rate. At 100 million characters of English narration, TTS is 10,000 units of $0.45, or $4,500 at the list rate. Replace the volumes with your own and put your current vendor's invoiced unit rate beside each line.

## Where the documented limits rule it out

Price is rarely the blocker. The limits are, so check them against your traffic before running any quality test.

### ASR

The endpoint takes the whole file in one request and returns the complete transcript; streaming recognition is not supported. Input is 16-bit PCM WAV or Ogg Opus, at most 8 MiB and at most 120 seconds. For stereo, only the left channel is recognized. There is no language parameter, since the language is detected from the audio.[3] The documented response has three fields: `request_id`, `text` and `duration_ms`. No timestamps, speaker labels or confidence scores are documented.[3]

In practice: two-channel call recordings with the agent on one channel and the customer on the other would lose one side. MP3 and other formats need transcoding first. A one-hour recording needs at least 30 chunks, with the boundary problem that comes with them.

### TTS

There are two voices, `stella` (female, default) and `tide` (male), and ten languages detected from the text. HTTP output is `wav` or `pcm`, and the WebSocket accepts `pcm` or `opus`. Speed control and resuming an interrupted request are not supported, and the text must pass content review or the request returns 400.[4] One request is capped at 10,000 billed characters.[4] If you ship a branded or cloned voice, or need a speaking-rate control, this endpoint does not replace it on the documented surface.

### OCR

The API accepts PDF, Word, PowerPoint and common image formats, up to 100 MiB and 1,000 pages, with 180 seconds total from the start of upload. It returns per-page text exactly as the model produced it, "without any cleanup", with `<｜ref｜>` and `<｜box｜>` tokens and coordinates normalized to 0–1000 where the model recognized layout.[2] That is raw material, not a table or key-value schema. If your current vendor returns structured fields, you will write the parsing layer yourself. DeepSeek separately documents file parsing, which adds extracted content to the chat context so the model can answer questions, and OCR does not pass the file to a chat model.[2]

## A test plan per modality

Build one golden set per modality from real production samples, stratified by the segments that already cause tickets. Run the incumbent and DeepSeek on the same files, and score with the same script. The method is the one in [replaying production traffic](https://infro.io/blog/can-you-replay-production-traffic-to-test-a-new-model-safely), applied to non-text outputs.

1. **OCR.** Sample 200 to 500 pages across scans, phone photos, born-digital PDFs, tables, forms and handwriting, in each language you serve. Measure character error rate on a hand-corrected subset, and field-level accuracy on the fields your downstream code reads (totals, dates, IDs). Count pages with `finish_reason: "length"`, which DeepSeek defines as incomplete page text.[2] Check reading order on multi-column pages and whether table cells stay attributable to their rows.
2. **ASR.** Build a set from real audio clipped to under 120 seconds, split by noise level, accent, domain vocabulary and language. Compute word error rate, but also entity accuracy for names, product terms, numbers and addresses, since a clean average hides failures there. Test language detection on short and code-switched clips, because you cannot set the language.[3]
3. **TTS.** Score intelligibility with a round trip through an independent ASR that is not the one under test, and have a human panel rate naturalness on your actual scripts. Include product names, abbreviations, numbers, URLs and Markdown-heavy text; `filter_markdown` defaults to true, so confirm that stripping does what you expect.[4] Measure time to first audio on both the HTTP stream and the WebSocket.
4. **Cost per accepted output.** For each modality compute `(billed units × rate + retries + preprocessing + human review) / outputs accepted`. A transcoding step for ASR and a parsing layer for OCR belong in the numerator.

```python
import requests

def ocr_page_texts(path, key):
    with open(path, "rb") as f:
        r = requests.post(
            "https://api.deepseek.com/v1/tools/ocr",
            headers={"Authorization": f"Bearer {key}"},
            data={"purpose": "text_recognition"},
            files={"file": f},
            timeout=200,
        )
    body = r.json()  # leading newlines are keep-alives; JSON still parses
    if "error" in body:  # status can already be 200
        raise RuntimeError(body["error"]["type"])
    truncated = [p["index"] for p in body["pages"] if p["finish_reason"] == "length"]
    return body["pages"], truncated
```

The error check mirrors what the docs describe: once recognition starts the HTTP status is already 200, and a failure arrives as an error object in the body instead of a result.[2]

## Rate limits and failure behavior

Each speech and OCR endpoint has its own concurrency ceiling, separate from the chat models: 15 OCR recognitions in progress per account, 50 in-progress requests each for ASR and TTS, with 429 beyond that.[2][3][4] Chat model limits are separate again, at 2,500 concurrent requests for `deepseek-flash` and 500 for `deepseek-v4-pro`, counted per account regardless of key.[8] A backfill of a large document archive will hit 15 quickly, and a burst of voice sessions will hit 50. Size your queue to those numbers, not to the model limits.

Failure shapes differ by endpoint, and your retry logic has to know each one. OCR separates failures that retrying will not fix (password-protected file, undecodable image, more than 1,000 pages) from transient ones (service busy, internal error).[2] ASR returns 503 when busy and 504 on a recognition timeout.[3] TTS is the awkward one: if synthesis fails after audio has started, the response is cut off, so a response that ends early must be treated as a failure.[4] A client that only checks the status code will play truncated speech.

## What changes for routing and fallbacks

Consolidating vendors reduces the number of contracts and keys, but it also removes the independent failure domains you had. Three modalities on one provider means one outage, one rate-limit policy and one terms-of-service change hits document intake, transcription and voice at once. Keep a second vendor warm for at least the modality where an outage is visible to a customer.

Fallback equivalence differs by modality, so do not write one rule for all three.

- **ASR** falls back most easily: audio in, text out. Differences show up in formatting, number style and missing timestamps, so normalize before comparing.
- **OCR** falls back with a schema cost. Raw coordinate-token text from one vendor and structured JSON from another need a shared intermediate format, or the fallback breaks the parser. See the same question for document extraction in [OpenRouter's Extractions API alpha](https://infro.io/blog/openrouter-s-extractions-api-alpha-can-it-carry-documents).
- **TTS** falls back worst. Voice ids are vendor-specific and do not carry over, so a failover changes the voice users hear, a product decision to make in advance.[9]

Make retry rules match the failure you documented. Send 503 and 504 elsewhere. Do not retry the non-transient OCR cases on a second vendor without checking the file, since a password-protected PDF fails everywhere. Alert on a 200 response whose body contains `error`. For equivalence testing on the fallback itself, reuse the method from [testing fallback equivalence](https://infro.io/blog/is-your-fallback-model-good-enough-test-fallback-equivalence).

Data handling is the other open question. The OCR, ASR and TTS pages read do not state retention or training use for submitted files and audio; the OCR page says only that the file is not stored in the Files API.[2] Get a written answer from DeepSeek's terms or the vendor before sending customer documents or recordings.

## Where a gateway helps, and where it does not yet

INFRO's audio documentation lists the connection kinds it serves for speech and transcription: ElevenLabs, Google AI (Gemini), xAI, MiniMax, Mistral for transcription only, and OpenAI, Azure OpenAI, Groq, Together AI, OpenRouter and OpenAI-compatible endpoints through OpenAI's audio API. DeepSeek is not named on that page.[9] DeepSeek's `/v1/tools/asr` and `/v1/tools/tts` shapes are its own, not OpenAI's audio shape, so do not assume an OpenAI-compatible connection reaches them; check the provider list before planning. INFRO's endpoint table covers speech, transcription, text and images, and has no OCR endpoint.[10]

For the incumbent vendors you do keep, the useful parts are the ones you would build anyway for this migration: named routes with priority or weighted targets and failover, rules that send matching requests to their own targets, and per-request usage with an estimated provider cost.[10] Entering your negotiated rates means the per-unit comparison above uses what you actually pay instead of list price. A weighted split with a small share on the candidate is the safe way to gather live evidence after the offline tests pass.

## Decision rule

Move a route to DeepSeek only when the documented limits fit that route and your golden set shows an accepted-output rate within your tolerance. In practice:

- Short voice-input clips under 120 seconds, mono, in a supported language: a candidate for ASR.
- Read-aloud of chatbot answers in the supported languages with a stock voice: a candidate for TTS.
- Text extraction where you already own the layout and parsing logic: a candidate for OCR.
- Stereo call recordings, branded voices, speed control, timestamps or structured document fields: stay on the incumbent for now.

Re-run the golden sets when DeepSeek changes the endpoints. Its change log shows model aliases being re-pointed to new versions before, with the same method names.[5] Pin your evidence to a date, not to an endpoint name.

## Questions

### Does the limited-time speech price last?

DeepSeek's pricing page lists a limited-time price beside the list price for TTS and ASR but the pages read do not give an end date. Forecast on the list price and treat the lower rate as a bonus until DeepSeek states otherwise.[7]

### Do the OCR, ASR and TTS endpoints use the OpenAI request shapes?

The documented shapes are DeepSeek's own: a multipart upload to /v1/tools/ocr with a purpose field, a multipart upload to /v1/tools/asr, and a JSON or WebSocket request to /v1/tools/tts. They are separate from the chat endpoints, so plan an adapter instead of changing a base URL.[2][3][4]

## Sources

1. DeepSeek Full-Suite App API Release 2026/11/13 — DeepSeek API Docs. https://api-docs.deepseek.com/news/news261113 (accessed 2026-11-15)
2. OCR — DeepSeek API Docs. https://api-docs.deepseek.com/guides/ocr (accessed 2026-11-15)
3. Speech to Text — DeepSeek API Docs. https://api-docs.deepseek.com/guides/asr (accessed 2026-11-15)
4. Text to Speech — DeepSeek API Docs. https://api-docs.deepseek.com/guides/tts (accessed 2026-11-15)
5. Change Log — DeepSeek API Docs. https://api-docs.deepseek.com/updates (accessed 2026-11-15)
6. Build a Chatbot — DeepSeek API Docs. https://api-docs.deepseek.com/guides/build_a_chatbot (accessed 2026-11-15)
7. Models & Pricing — DeepSeek API Docs. https://api-docs.deepseek.com/quick_start/pricing (accessed 2026-11-15)
8. Rate Limit & Isolation — DeepSeek API Docs. https://api-docs.deepseek.com/quick_start/rate_limit (accessed 2026-11-15)
9. Audio & speech — INFRO Docs. https://infro.io/docs/modalities/audio (accessed 2026-11-15)
10. INFRO documentation overview — INFRO. https://infro.io/docs (accessed 2026-11-15)
