BroadRouter
Get started

Text, speech or vision? Start with the task

By the BroadNet Inference team · 7 min read · Published

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.

“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 and API reference, 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 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 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).

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 Arabic: Gulf, Egyptian, Levantine, Maghrebi and Modern Standard, per BroadNet $0.0042 per minute (about $0.25 an hour)
BroadNet 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 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 Text, image 1,048,576 $0.175 / $0.52 Top-up required
Qwen3.8 27B Text, image 262,144 $0.175 / $2.17 Top-up required
Gemma 4 VL 26B Text, image 32,768 $0.10 / $0.22 $5 starting credit
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. Document extraction end to end is in extracting data from documents with a 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).

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 covers that step. Recordings over the size cap need splitting; the audio splitter 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 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 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 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 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 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 compares prices.

BroadNet’s research catalogue 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 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.
  • 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 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.
  • 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. For speaking, image generation, live voice or embeddings, use another service. Prices for everything above are on the pricing page.

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.

Read as MarkdownAsk ChatGPTAsk ClaudeAsk Perplexity