---
title: "Text, speech or vision AI: choose by task, not by model"
description: "Pick text chat, image input or audio transcription by task, with the models and limits BroadNet documents, and what it does not offer, such as TTS."
url: https://broadrouter.com/blog/text-speech-vision/
lang: en
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

# Text, speech or vision? Start with the task

By the BroadNet Inference team · 7 min read · Published 2026-11-15

Start from your input and output. Text in, text out is chat. A photo or scan in, text out is chat with an image, on a model that accepts images. Recorded speech in, text out is transcription; speech to an answer is transcription then chat. BroadNet does not offer text-to-speech, image generation or embeddings.

## Key takeaways

-   Pick the input type first. It decides the endpoint, which decides the models you can use.
-   On BroadNet, three chat models accept images (DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B); GLM 5.3 is text only.
-   Speech goes to /v1/audio/transcriptions as a WAV or MP3 file of up to 26,214,400 bytes. Always send the language.
-   BroadNet offers no text-to-speech, live voice, image generation or embeddings endpoint. Plan a second provider if you need them.
-   Build a separate evaluation set for each input type, plus one for the whole chain when speech feeds a chat model.

**On this page**

1.  Which input type does your task need?
2.  What is the difference between chat and transcription?
3.  Which models accept images?
4.  How do you route each input in code?
5.  What if the document is already text?
6.  How do the costs compare?
7.  What isn’t offered, and what should you do instead?
8.  Why do you need a separate evaluation set for each input?
9.  Where BroadNet Inference fits

“Which model should we use?” is the second question. The first is “what goes in, and what has to come out?” A photo of an invoice, a voice note from a customer and a typed question each go to a different kind of endpoint, and each endpoint has its own models, limits and failure modes. Pick the task first and the model list shrinks to two or three.

This guide maps common tasks to input types, then to what BroadNet Inference documents for each. BroadRouter is BroadNet’s own site; the model facts below come from BroadNet’s [pricing feed](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-text-speech-vision&utm_content=body) and [API reference](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-text-speech-vision&utm_content=body), checked on 15 November 2026.

## Which input type does your task need?

| Your task | Input | Output | Endpoint | BroadNet models |
| --- | --- | --- | --- | --- |
| Answer, summarise, classify or translate text | Text | Text | Chat completions | Any of the four chat models |
| Call your own functions or tools | Text | Tool calls | Chat completions | GLM 5.3, Qwen3.8 27B (documented) |
| Read a photo, scan, screenshot or form | Image + text | Text or JSON | Chat completions with an image | DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B |
| Turn a recording or voice note into text | Audio file | Text | Audio transcriptions | Transcribe Arabic, Transcribe (14 languages) |
| Summarise a call or answer a voice note | Audio file | Text | Transcription, then chat | One of each |
| Speak an answer aloud | Text | Audio | Text-to-speech | Not offered |
| Hold a live voice conversation | Audio stream | Audio | Realtime voice | Not offered |
| Create an image | Text | Image | Image generation | Not offered |
| Semantic search over documents | Text | Vectors | Embeddings | Not offered |

“Vision” in this table means image understanding: the model reads an image you send. It does not mean generating images. The [vision language model](https://broadrouter.com/glossary/vision-language-model/) glossary entry explains the difference.

## What is the difference between chat and transcription?

They are different endpoints with different request shapes, billing units and models.

**Chat** (`POST /v1/chat/completions`) takes a list of messages as JSON and returns text. It is billed per token, input and output separately, and each model has a [context window](https://broadrouter.com/glossary/context-window/) that holds prompt and answer together. On BroadNet, three of the four chat models reason before answering, and that reasoning counts toward `max_tokens`, so leave room ([reasoning tokens and empty answers](https://broadrouter.com/guides/reasoning-tokens-empty-response/)).

**Transcription** (`POST /v1/audio/transcriptions`) takes an audio file as a multipart upload and returns the transcript. It is billed per audio minute. BroadNet’s docs specify WAV or MP3 up to 26,214,400 bytes per file, and say to always send `language`, because Arabic can otherwise come back transliterated into Latin letters.

| Model | Languages | Price |
| --- | --- | --- |
| [BroadNet Transcribe Arabic](https://broadrouter.com/models/cohere-transcribe-arabic/) | Arabic: Gulf, Egyptian, Levantine, Maghrebi and Modern Standard, per BroadNet | $0.0042 per minute (about $0.25 an hour) |
| [BroadNet Transcribe](https://broadrouter.com/models/cohere-transcribe/) | 14, including English, Spanish, French, Mandarin and Arabic | $0.002 per minute (about $0.12 an hour) |

A chat model on BroadNet does not take audio, and a transcription model does not answer questions. A voice assistant that replies in text is two calls: transcribe, then chat. [Arabic meeting minutes from recordings](https://broadrouter.com/blog/arabic-meeting-minutes-from-recordings/) builds exactly that chain.

## Which models accept images?

The ones whose feed entry lists `image` in `modalities`. On 15 November 2026:

| Model | Inputs | Context | Input / output per 1M tokens | Access |
| --- | --- | --- | --- | --- |
| [DeepSeek V4.1 Flash](https://broadrouter.com/models/deepseek-v4.1-flash/) | Text, image | 1,048,576 | $0.175 / $0.52 | Top-up required |
| [Qwen3.8 27B](https://broadrouter.com/models/qwen3.8-27b/) | Text, image | 262,144 | $0.175 / $2.17 | Top-up required |
| [Gemma 4 VL 26B](https://broadrouter.com/models/gemma-4-vl-26b/) | Text, image | 32,768 | $0.10 / $0.22 | $5 starting credit |
| [GLM 5.3](https://broadrouter.com/models/glm-5.3/) | Text only | 1,048,576 | $0.78 / $3.46 | Top-up required |

Send the image as a `data:` URL inside the message content, with an accurate MIME type. BroadNet’s docs say vision is offered “only where the model row explicitly says images or vision”. The docs don’t list accepted image formats, so test each format you plan to accept. On a pay-as-you-go key an image is billed as input tokens, and a larger image uses more; resize before sending and estimate with the [image token calculator](https://broadrouter.com/tools/image-token-calculator/). Document extraction end to end is in [extracting data from documents with a vision LLM](https://broadrouter.com/blog/extract-data-from-documents-with-vision-llm/).

## How do you route each input in code?

This function picks the endpoint from the file type, checks the documented limits before sending, and reads the list of image-capable models from the live feed rather than hard-coding it. It uses the OpenAI Python SDK, which works with BroadNet after changing the base URL ([setup guide](https://broadrouter.com/guides/openai-python-sdk/)).

```python
import base64, json, mimetypes, os, urllib.request
from pathlib import Path
from openai import OpenAI

client = OpenAI(base_url=os.environ.get("BROADNET_BASE_URL", "https://inference.broadnet.ai/v1"),
                api_key=os.environ["BROADNET_API_KEY"])
feed = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json", timeout=30))
live = [m for m in feed["models"] if m.get("status", "live") == "live"]
VISION = {m["id"] for m in live if "image" in m.get("modalities", [])}
AUDIO_TYPES = {"audio/wav", "audio/x-wav", "audio/mpeg"}       # WAV or MP3, per the docs
AUDIO_MAX = 26_214_400                                         # bytes per file, per the docs
IMAGE_TYPES = {"image/jpeg", "image/png", "image/webp"}        # your allow-list; test each one

def run(task: str, path: str | None = None, *, chat_model="broadnet/gemma-4-26b-a4b",
        stt_model="broadnet/cohere-transcribe-arabic", language="ar") -> str:
    kind = mimetypes.guess_type(path)[0] if path else None
    if kind is None:                                           # text only
        r = client.chat.completions.create(model=chat_model, max_tokens=1500,
                                           messages=[{"role": "user", "content": task}])
        return r.choices[0].message.content
    if kind in AUDIO_TYPES or kind.startswith("audio/"):
        if kind not in AUDIO_TYPES:
            raise ValueError(f"{kind}: convert first, e.g. ffmpeg -i in.ogg -ar 16000 -ac 1 out.wav")
        if Path(path).stat().st_size > AUDIO_MAX:
            raise ValueError("over 26,214,400 bytes: split the audio before sending")
        with open(path, "rb") as f:                            # step 1: speech to text
            text = client.audio.transcriptions.create(model=stt_model, file=f, language=language).text
        return run(f"{task}\n\nTranscript:\n{text}", chat_model=chat_model) if task else text
    if kind in IMAGE_TYPES:
        if chat_model not in VISION:
            raise ValueError(f"{chat_model} takes no images here; pick one of {sorted(VISION)}")
        data = base64.b64encode(Path(path).read_bytes()).decode()
        r = client.chat.completions.create(model=chat_model, max_tokens=1500, messages=[{"role": "user",
            "content": [{"type": "text", "text": task},
                        {"type": "image_url", "image_url": {"url": f"data:{kind};base64,{data}"}}]}])
        return r.choices[0].message.content
    raise ValueError(f"unsupported input type {kind}")
```

We tested it with `BROADNET_BASE_URL` pointed at a local mock server (no live API call) and the live pricing feed. Text, a WAV file, a WAV file with a follow-up task, and a PNG each reached the right mock endpoint. Sending the PNG with `chat_model="broadnet/glm-5.3"` was refused before any request, listing the three image-capable IDs from the feed. An `.ogg` file was refused with the ffmpeg command to convert it; [transcribing WhatsApp voice notes](https://broadrouter.com/guides/transcribe-whatsapp-voice-notes/) covers that step. Recordings over the size cap need splitting; the [audio splitter](https://broadrouter.com/tools/audio-splitter-ffmpeg/) builds the ffmpeg commands.

## What if the document is already text?

Then don’t send a picture of it. A PDF exported from an accounting system or a word processor usually has a text layer; extract it with a PDF library and send the text to a chat model. That is cheaper than an image on a pay-as-you-go key, avoids misreads, and works on GLM 5.3 too. Keep vision for scans, phone photos, handwriting, stamps and screenshots, where there is no text layer to extract.

A useful rule in a document pipeline: try text extraction first, check whether it returned real text (not empty pages or garbled characters), and fall back to the image only when it didn’t. For Arabic PDFs, read a sample of the extracted text before trusting it: depending on how the PDF was produced, extraction can return Arabic letters in the wrong order or in unjoined presentation forms. [Arabic OCR with a vision LLM](https://broadrouter.com/blog/arabic-ocr-vision-llm/) covers the cases where the image is the better source.

## How do the costs compare?

Each input type is billed in its own unit, so compare per task, not per request:

-   **Text** is billed per input and output token. Arabic often needs more tokens than English for the same content; the [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/) measures it.
-   **Images** on pay-as-you-go are input tokens at the model’s input price, so a large photo can cost more than a page of text. On a DeepSeek session plan, images are part of the flat price.
-   **Audio** is billed per minute of audio, whatever is said. On BroadNet, 10,000 Arabic voice notes of 30 seconds each come to about $21.00 with the Arabic model. The [speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) does other volumes.

A chain adds its parts: a voice note answered by a chat model costs the transcription minutes plus the chat tokens of the transcript and the answer. The [LLM API cost calculator](https://broadrouter.com/tools/llm-api-cost-calculator/) handles the chat side.

## What isn’t offered, and what should you do instead?

BroadNet’s API reference documents two inference endpoints: chat completions and audio transcriptions. So there is no:

-   **Text-to-speech.** No `/v1/audio/speech`. If your product must talk back, pair BroadNet transcription and chat with a separate TTS service.
-   **Live voice.** Transcription takes an uploaded file, not a live audio stream. For a phone agent that must respond mid-call, you need a realtime voice stack elsewhere. [Recording browser audio for transcription](https://broadrouter.com/blog/record-browser-audio-transcription-api/) shows the file-based alternative.
-   **Image generation.** Vision here reads images; it doesn’t create them.
-   **Embeddings.** No `/v1/embeddings`. For retrieval you need an embedding model from another provider or self-hosted; the [embedding cost calculator](https://broadrouter.com/tools/embedding-cost-calculator/) compares prices.

BroadNet’s [research catalogue](https://www.broadnet.ai/inference/models) does list text-to-speech, image-generation and embedding models, marked as benchmarked in its lab. That records what BroadNet tested, not what its API sells; [reading a model catalogue](https://broadrouter.com/blog/understand-model-status/) explains the difference.

## Why do you need a separate evaluation set for each input?

Because each input type fails differently, and an average across them hides the failures.

-   **Text:** score on real user messages, with code checks where possible. The method is in [evaluating an LLM before switching](https://broadrouter.com/blog/evaluate-llm-before-switching/).
-   **Images:** use real photos at real quality: phone pictures at an angle, faded receipts, stamps over text. Score each field separately. A clean PDF render scores far higher than the photos your users will send.
-   **Speech:** measure [word error rate](https://broadrouter.com/glossary/word-error-rate/) on your own recordings, split by dialect, speaker and line quality, and check the words that matter (names, numbers, amounts) separately. See [Arabic ASR WER explained](https://broadrouter.com/blog/arabic-asr-wer-explained/).
-   **Chains:** when speech feeds a chat model, score both steps and the end result. A misheard number becomes a confident wrong answer, and only an end-to-end test shows how often.

Keep the sets apart, version them, and re-run the relevant one whenever you change a model or prompt.

## Where BroadNet Inference fits

BroadNet Inference covers the first five rows of the task table with one key and one base URL: text chat, tool calling on GLM 5.3 and Qwen3.8 27B, image understanding on three models, and Arabic or multilingual transcription. Gemma 4 VL 26B and both transcription models run on the $5 starting credit; DeepSeek, GLM and Qwen need a top-up. Inference content is not retained; necessary account, billing and security metadata is retained as described in BroadNet’s [privacy statement](https://www.broadnet.ai/inference-privacy). For speaking, image generation, live voice or embeddings, use another service. Prices for everything above are on the [pricing page](https://broadrouter.com/pricing/).

Free tools for this

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[All free tools](https://broadrouter.com/tools/)

## Terms in this article

[Token](https://broadrouter.com/glossary/token/)

A token is the unit of text a language model reads and writes: a word, part of a word, a punctuation mark or a byte sequence produced by the model's tokenizer. LLM APIs count, limit and usually bill usage in tokens.

[Tool calling](https://broadrouter.com/glossary/tool-calling/)

Tool calling, also called function calling, is an LLM API feature in which the model returns a structured request to run a function the developer has defined, with JSON arguments. The application runs the function and sends the result back; the model never runs code itself.

[Speech-to-text](https://broadrouter.com/glossary/speech-to-text/)

Speech-to-text, also called automatic speech recognition (ASR), is technology that converts spoken audio into written text. A speech-to-text API accepts an audio file or stream and returns a transcript, usually priced per minute of audio. Accuracy is measured with word error rate and varies with accent, dialect and recording quality.

[Embeddings](https://broadrouter.com/glossary/embeddings/)

Embeddings are lists of floating-point numbers (vectors) that a model produces to represent a piece of text, an image or other input. Inputs with similar meaning get vectors that are close together, so distance between vectors can rank search results, cluster documents or find related items.

[WAV](https://broadrouter.com/glossary/wav/)

WAV (Waveform Audio File Format, or WAVE) is an audio container built on Microsoft and IBM's RIFF format. It usually holds uncompressed linear PCM samples, so its size is predictable: sample rate times bytes per sample times channels, per second.

[Chat Completions API](https://broadrouter.com/glossary/chat-completions-api/)

The Chat Completions API is OpenAI's HTTP endpoint, POST /v1/chat/completions, that takes a model name and a list of role-tagged messages and returns the model's next message. Its request and response shape became the common format that OpenAI-compatible providers and SDKs reuse.

[Prepaid credit](https://broadrouter.com/glossary/prepaid-credit/)

Prepaid credit is money added to an API account before use. Each request deducts its cost from the balance, and when the balance runs out, metered requests stop until you top up. It caps spend at what you have paid in.

[Pay-as-you-go](https://broadrouter.com/glossary/pay-as-you-go/)

Pay-as-you-go is a pricing model in which you pay only for what you use, metered per unit such as tokens, requests or audio minutes, with no subscription or minimum commitment. Most LLM APIs bill this way, from a prepaid balance or a periodic invoice.

## Questions

### Which AI model should I use for images?

One that accepts image input on the API you use. On BroadNet Inference that is DeepSeek V4.1 Flash, Qwen3.8 27B or Gemma 4 VL 26B, according to its pricing feed; GLM 5.3 takes text only. Send the image as a data URL in the chat message.

### Can a chat model transcribe audio?

Not on BroadNet Inference. Audio goes to the transcription endpoint, /v1/audio/transcriptions, with a transcription model. If you then need a summary or answer, send the transcript to a chat model as a second step.

### Does BroadNet Inference offer text-to-speech or image generation?

No. Its API reference documents chat completions and audio transcription only. Text-to-speech and image-generation models appear in BroadNet's research catalogue as benchmarked, which is not the same as being offered.

### What audio formats does BroadNet accept?

WAV (audio/wav) or MP3 (audio/mpeg), up to 26,214,400 bytes per file. Convert other formats, such as a WhatsApp .ogg voice note, with ffmpeg first, and always send the language parameter.

### How is an image billed?

On a pay-as-you-go key, BroadNet bills an image as input tokens at the model's input price, and a larger image uses more tokens. On a DeepSeek session plan, images are part of the flat price.

## Keep reading

-   [Extract invoice, receipt and form data to JSON with a vision LLM](https://broadrouter.com/blog/extract-data-from-documents-with-vision-llm/)
-   [Arabic speech-to-text API: how to choose one in 2026](https://broadrouter.com/blog/arabic-speech-to-text-api-buyers-guide/)
-   [Multilingual speech-to-text API: 14 languages, one endpoint](https://broadrouter.com/blog/multilingual-speech-to-text-api/)
-   [Cheapest vision LLM API: cost per image and per page, worked out](https://broadrouter.com/blog/cheapest-vision-llm-api/)
-   [Arabic meeting minutes from recordings: an API pipeline](https://broadrouter.com/blog/arabic-meeting-minutes-from-recordings/)
-   [Live, on request, research: read a model catalogue clearly](https://broadrouter.com/blog/understand-model-status/)
-   [How to evaluate an LLM before switching providers](https://broadrouter.com/blog/evaluate-llm-before-switching/)
-   [A private endpoint starts with a clear workload](https://broadrouter.com/blog/private-endpoint-planning/)
-   [Before fine-tuning: define the problem to solve](https://broadrouter.com/blog/fine-tuning-readiness/)
-   [Guide: Read Arabic invoices and receipts with a vision model](https://broadrouter.com/guides/read-arabic-invoices-with-vision/)
-   [Guide: Arabic speech-to-text API, step by step](https://broadrouter.com/guides/arabic-speech-to-text-api/)
-   [Guide: Transcribe WhatsApp voice notes to text with an API](https://broadrouter.com/guides/transcribe-whatsapp-voice-notes/)
-   [Guide: Use the OpenAI Python SDK with BroadNet Inference](https://broadrouter.com/guides/openai-python-sdk/)

Try it on your real workload. New accounts start with $5 of credit for Gemma and transcription. DeepSeek, GLM and Qwen3.8 need a top-up.

[Get started](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-text-speech-vision&utm_content=page-cta) ·

**Sources**

-   [BroadNet Inference API reference: model IDs, chat with an image, transcription formats and size, capability status (checked 2026-11-15)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-text-speech-vision&utm_content=sources)
-   [BroadNet Inference pricing.json: modalities, languages and prices per model (checked 2026-11-15)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-text-speech-vision&utm_content=sources)
-   [BroadNet Inference model catalogue: live models, and text-to-speech and image models listed as benchmarked (checked 2026-11-15)](https://www.broadnet.ai/inference/models)
-   [BroadNet Inference privacy and data retention statement (checked 2026-11-15)](https://www.broadnet.ai/inference-privacy)
