BroadRouter blog
Updated
Articles from the BroadNet Inference team on running LLMs and speech to text in production: what flat-rate plans cost against per-token billing, how to run agents in parallel, Arabic AI, and data retention. Every price comes from BroadNet's published pricing file.
LLM API price changes in October 2026: 3 rises, no cuts
23 pricing-page changes at 5 of 7 LLM API providers in October 2026: 3 price rises, no cuts, 9 new models priced and 11 removed. Archive links for each.
A private endpoint starts with a clear workload
What to define before asking for a private LLM endpoint: workload, tokens per second, concurrency, context, region, licence and budget, then how to test it.
Add diacritics to Arabic text with an LLM: prompt, checks, DER
Restore Arabic diacritics (tashkeel) with an LLM API: a prompt that keeps every letter, a check that rejects edits, DER and WER scoring, and when to use CATT.
Arabic grammar and spelling correction with an LLM: a how-to
Correct Arabic spelling and grammar with an LLM API: a minimal-edit prompt, a guard against rewrites, word-level edits by error class and M2-style scoring.
Arabic meeting minutes from recordings: an API pipeline
Turn Arabic meeting recordings into minutes with decisions and action items: transcribe, clean, summarise with an LLM into JSON, and check names and dates.
Arabic named entity extraction with an LLM: JSON, dates and checks
Extract Arabic names, organisations, places and Hijri dates to JSON with an LLM: a prompt, span checks that ignore diacritics, date conversion and a scoring script.
Arabic OCR API comparison: Google, Azure, Textract, Mistral, LLMs
Which OCR APIs officially support Arabic, printed and handwritten, what each returns and what it costs per 1,000 pages, compared with vision LLM APIs.
Arabic subtitles (SRT) from a speech-to-text API: what you need
What an SRT file needs, which speech-to-text APIs return timestamps or SRT for Arabic, and a tested pipeline that builds subtitles from a text-only API.
Arabic text classification with an LLM: sentiment, intent, triage
Classify Arabic reviews, messages and support tickets with an LLM API: label design, a dialect-aware prompt, JSON output, macro F1 testing and cost at volume.
Arabic text normalization for search and RAG: what to change, what not
Tashkeel, alef forms, ta marbuta, hamza seats, Persian letters, digits and Unicode: which Arabic normalization rules help search, which hurt, and tested Python code.
Arabic text summarization with an LLM: prompts, length and scoring
Summarise Arabic articles, reports and dialect messages with an LLM API: prompt patterns, word-count control, number checks, and why default ROUGE gives Arabic 0.
Artificial Analysis alternatives: where to compare LLMs in 2026
Artificial Analysis alternatives compared: Arena, Epoch AI, Vals AI, OpenRouter rankings, Hugging Face and price data, by what each one measures and when to use it.
Before fine-tuning: define the problem to solve
When prompting, RAG or evaluation fixes the problem and fine-tuning is not needed, what training data you need, and how to test a fine-tune before you ask for one.
BroadNet's GPU hardware and serving approach, as BroadNet describes it
What BroadNet says about the hardware behind BroadNet Inference: three GPU tiers from B300 to client appliances, throughput per GPU, and what its tests taught it.
Cache LLM API responses to cut cost: an exact-match cache in Python
A tested exact-match cache for LLM API responses in Python: what goes in the key, what never to cache, TTLs, privacy and how to measure the hit rate before building.
Claude Code with open models: proxies, native endpoints and limits
Claude Code speaks the Anthropic Messages API. How to run it on open models through a LiteLLM proxy or a native endpoint, and what breaks along the way.
Design an AI experience for multiple languages
Design an AI product for Arabic, English and Spanish users: UI locale vs model language, RTL and mixed text, numbers, dates, detection and cost.
Do LLM API prices only go down? 52 rises and how to budget for them
LLM API prices do go up. We found 52 list-price rises on the same model in archived pricing pages, 2024 to 2026, median 40%. All sources, plus a budget rule.
Egypt's data protection law (Law 151 of 2020) and LLM APIs
Sending Egyptians' personal data to an LLM or speech-to-text API abroad: what Law 151 of 2020 and Decision 816 of 2025 say about transfers, licences and breaches.
How often do LLM API prices change? 3 years of archived pricing pages
We read 308 archived pricing pages from 11 LLM API providers, 2023 to 2026. 80% of models never changed price; DeepInfra made 75% of all list-price changes.
How to fix invalid JSON from an LLM: causes, repair, retry
Why LLMs return broken JSON (code fences, prose, max_tokens cut-offs, trailing commas) and a tested Python function that repairs what is safe and rejects the rest.
How to reduce LLM API costs: a 10-step checklist, in order
Cut an LLM API bill in the right order: measure, cache the prefix, trim prompts, cap output and reasoning, right-size the model, batch, and know when flat rate wins.
How to test an LLM for sensitive-data safety: BroadNet's method
BroadNet's published method for testing whether an LLM leaks credentials, PII, health or financial data before you deploy it: categories, leak vs miss, 3+ runs.
Live, on request, research: read a model catalogue clearly
How to tell which catalogue models you can call today, which need an enquiry and which were only tested, using BroadNet's catalogue and /v1/models as the example.
LLM API failover: fall back to a second provider in your own code
How to fail over between OpenAI-compatible LLM providers: which errors to fail over on, a circuit breaker, model ID mapping, streaming, cost and privacy parity.
LLM API price cuts 2023–2026: the biggest drops, with sources
The largest LLM API price cuts from 2023 to 2026, each with before and after Internet Archive links: o3, Codestral, Gemini 1.5, plus the rises few people noticed.
LLM API rate limits by provider: RPM, TPM and concurrency compared
Entry-tier LLM API rate limits from 13 providers, read from their docs: OpenAI, Anthropic, Gemini, Groq, DeepSeek, Fireworks and others, plus what RPM and TPM mean.
LLM API SLAs compared: what Azure, Bedrock, Google and OpenAI promise
What each LLM API provider commits to in writing: uptime percentage, what counts as downtime, service credits and latency targets, read from the SLA pages.
LLM batch processing without a Batch API: a resumable runner
Run 10,000 to 1,000,000 prompts through a chat-completions API with no Batch API: concurrency caps, rate pacing, retries, resumable checkpoints and the time math.
Make human review part of your document AI workflow
Design the human review step of a document-AI pipeline: validation rules, what to send to a person, random audit samples, an audit trail and the review rate.
Migrating off the OpenAI API: a code walkthrough in Python, Node, cURL
The code changes to move from OpenAI to an OpenAI-compatible API: client setup, Responses to Chat Completions, tools, streaming, embeddings and a smoke test.
Models BroadNet evaluated and ruled out, and why
BroadNet publishes the models it tested and rejected, with reasons: chat models that failed its credential-safety gate, speech, OCR and embedding models that lost.
Open-weight vs closed model API cost: what the price data shows
Are open-weight models cheaper through an API than GPT, Claude or Gemini? Per-token prices from providers' own pages, host spreads and a worked cost per user.
OpenAI vs Anthropic vs Google API price history, 2023–2026
GPT, Claude and Gemini API prices side by side from archived pricing pages, 2023 to 2026: which lines got cheaper, which got dearer, each with an archive link.
OpenAI-compatible API base URLs: 14 providers, checked
The base_url for 14 OpenAI-compatible LLM APIs, each read from the provider's own docs, with the endpoints they list and the quirks that break a drop-in switch.
OpenClaw and Hermes Agent on a cheap model: setup and token math
Connect OpenClaw or Hermes Agent to an OpenAI-compatible endpoint, see why scheduled checks burn tokens, and cut the bill with lighter context and cheaper models.
Prompt injection in coding agents: defences that actually hold
Where prompt injection reaches a coding agent, and the layered defences vendors and researchers document: sandboxing, egress limits, allow-lists and approval.
RAG chunk size and overlap: what they do to retrieval and cost
How chunk size and overlap change RAG recall, index size, embedding cost and the tokens every query sends to the LLM, with published results and worked numbers.
Record audio in the browser and send it to a speech-to-text API
Record the microphone with MediaRecorder, turn WebM or Safari MP4 into 16 kHz WAV, and send it to a transcription API through a small server that keeps the key.
Reduce prompt tokens: measured cuts for system prompts, tools, data
Measured token savings from trimming system prompts, few-shot examples, tool schemas, data formats, chat history and Arabic diacritics, counted with real tokenizers.
Same model, different host: how much LLM API prices vary
For 119 models sold by several hosts, the dearest list price is a median 1.76 times the cheapest. Data from 41 providers' own pricing pages, November 2026.
Saudi and UAE PDPL and LLM APIs: a cross-border checklist
Sending personal data to an LLM API from Saudi Arabia or the UAE: what the PDPL transfer rules say, what to ask a provider, and when in-country inference matters.
Setting max_tokens for reasoning models: a budgeting method
Why reasoning models return empty replies at low max_tokens, and how to size the budget from measured percentiles, the context window and a retry that escalates.
Text, speech or vision? Start with the task
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.
The Safety Map: how 39 LLMs handle sensitive data
BroadNet surveyed 39 LLMs from 14 labs on credentials, PII, health and financial data: what transferred, what did not, and the tool-call and reasoning leaks.
Transcribe long audio over 25 MB: split, send and stitch
How to transcribe recordings over a speech-to-text API file limit: shrink the file, split at silences with ffmpeg, send chunks in parallel and stitch the text.
Translate app strings to Arabic with an LLM: placeholders and plurals
Translate i18n JSON files to Arabic with an LLM API: freeze placeholders, generate all six Arabic plural forms, validate ICU syntax in CI and isolate inserted names.
Translate Arabic audio to English text with an API: a tested pipeline
Turn Arabic recordings into English text with two API calls: transcribe with language=ar, then translate with an LLM, with number checks, chunking, cost and scoring.
Uno in vLLM: what BroadNet's serving study measured
BroadNet built the Uno self-drafting adapter into vLLM and measured it on an H100: 2.58x plain throughput at one stream, 1.74x at 32. The method, DOI and limits.
Uno on Gemma 4 26B: BroadNet's mixture-of-experts study
BroadNet trained the first Uno self-drafting adapter for a mixture-of-experts model, Gemma 4 26B A4B. What it measured, when self-drafting pays, and the DOI.
What one AI coding agent run costs: steps, context growth, caching
Why a coding agent run costs more per step the longer it goes, how caching changes the total, and when a flat session beats per-token billing. Worked token math.
10 ways to cut coding agent LLM costs, with estimated savings
Ten concrete ways to lower what Cline, Aider, opencode or your own coding agent spends on tokens, each with the math behind the saving and how to measure it.
A weekly LLM plan for short projects: Orbit vs hour vs month
When a one-week unlimited DeepSeek V4.1 Flash plan beats an hourly session, a monthly plan or pay-per-token, with the math for hackathons, sprints and migrations.
Agent token budget: where an agent loop's tokens go
System prompt, tool schemas, file reads, history and reasoning: how an agent loop spends tokens, how to measure each part from usage data, and what to trim first.
Arabic ASR word error rate (WER) explained
What word error rate means, how to compute it, and why Arabic WER is so sensitive to diacritics, spelling normalisation and dialects. With Python and real numbers.
Arabic dialect speech recognition: Gulf, Egyptian, Levantine, Maghrebi
Why speech-to-text struggles with Gulf, Egyptian, Levantine and Maghrebi Arabic, and how to build a dialect test set that shows how a provider will do on your audio.
Arabic OCR vs vision LLMs: reading Arabic documents and invoices
When to use classic OCR and when a vision LLM for Arabic invoices, receipts and forms: accuracy traps, JSON output, cost per page and a validation pipeline.
Arabic prompt engineering: register, RTL, numerals and mixed text
Write prompts that get good Arabic from an LLM: pick register and dialect, control numerals and dates, keep RTL formatting clean and handle Arabic–English mixing.
Arabic RAG: normalisation, chunking and retrieval that works
Retrieval-augmented generation over Arabic documents: normalise alef, ya and ta marbuta, chunk sensibly, pick multilingual embeddings, add keyword search.
Arabic speech-to-text API: how to choose one in 2026
How to pick an Arabic transcription API: word error rate, dialects, file limits, price per audio hour and privacy, plus a test plan for your own recordings.
Arabic WhatsApp chatbot architecture: voice notes to replies
A working architecture for an Arabic WhatsApp assistant: webhook, queue, voice-note transcription, LLM reply, policy rules and costs, with Python you can adapt.
Arabic–English translation with LLMs: prompts, glossaries, evaluation
Translate Arabic to English and back with an LLM API: prompts that keep tone, glossaries for fixed terms, numbers and names, and how to evaluate quality.
Arabizi and LLMs: handling Franco-Arabic with numbers like 3 and 7
Arabizi writes Arabic in Latin letters with digits like 3 for ع and 7 for ح. How to detect it, convert it to Arabic script with an LLM, and reply the right way.
Best LLM for Aider: how to choose a model and connect it
How to pick the best LLM for Aider: edit-format discipline, context size and cost per hour, a one-hour test on your own repo, and the exact OPENAI_API_BASE setup.
Best open model for coding agents: pick by tools, context and cost
GLM 5.3, DeepSeek V4.1 Flash, Qwen3.8 27B or Gemma 4 for your coding agent? Pick by tool calling, context size, reasoning and cost per task, with the math.
Cached input tokens: how to cut an LLM API bill
Cached input costs a fraction of normal input. How prompt caching is billed, how to read cached_tokens in usage, and how to structure prompts to hit it.
Cheapest vision LLM API: cost per image and per page, worked out
What a vision LLM call costs per image and per document page: token math for Gemma 4, Qwen3.8 27B and DeepSeek V4.1 Flash, plus where DeepInfra is cheaper.
Choosing an LLM API for Arabic: what to test
How to pick an LLM for Arabic apps: dialect understanding, writing quality, translation, Arabic documents and images, cost, plus a test set you can build in a day.
Cline vs Roo Code vs Aider for teams on open models (2026)
Cline, Roo Code (now archived, continued as Zoo Code) and Aider compared on what matters with open models: tool calls, context use, MCP, git and approvals.
Context management for long-running agents with a 1M window
How to keep long agent sessions accurate and affordable with a 1M-token window. Append-only history, cache-friendly prompts, when to compact, and what to drop first.
DeepSeek API alternatives: 5 ways to call DeepSeek models
Calling DeepSeek models through the official API, an aggregator, a cloud catalogue, your own GPUs or BroadNet Inference: trade-offs on price, privacy and limits.
DeepSeek V4.1 Flash API pricing: per token, cached and plans
DeepSeek V4.1 Flash API pricing per 1M input, cached and output tokens, flat monthly, weekly and hourly plans, and how DeepSeek, DeepInfra and Fireworks compare.
Extract invoice, receipt and form data to JSON with a vision LLM
A production pipeline for invoices, receipts and forms: image prep, a JSON schema prompt, Pydantic validation, arithmetic checks, retries and a human review queue.
Flat-rate vs pay-per-token LLM API: the break-even math
When does a flat-rate LLM plan beat paying per token? Four worked monthly bills for DeepSeek V4.1 Flash, the break-even volume, and how to measure your own.
Free LLM API credit: how far a starting credit really goes
What a free LLM API credit really buys: tokens, audio minutes and hourly keys on the BroadNet starting credit, compared with Gemini and OpenRouter free tiers.
GDPR and LLM APIs: 15 questions to ask your provider
A GDPR checklist for LLM APIs: DPA terms, subprocessors, retention, training, international transfers and breach notice, with the GDPR articles behind each question.
GLM 5.3 vs DeepSeek V4.1 Flash: which one to use, and when
GLM 5.3 vs DeepSeek V4.1 Flash on price, context, tools, structured output, images and reasoning, with worked workload costs and a simple rule for when to use each.
Gulf, Egyptian and Levantine Arabic: how LLMs handle dialects
How LLMs cope with Gulf, Egyptian and Levantine Arabic: where they fail, how to prompt for dialect, how to test it, and what BroadNet reports for Qwen3.8 27B.
Hourly LLM API key: a flat price per hour, explained
BroadNet's hourly key buys one hour of Gemma 4 VL 26B on one stream for a fixed price. What it includes, its limits, who it suits and when it pays off.
How inference providers price open models: 6 compared
How OpenRouter, Together AI, Fireworks, Groq, DeepInfra and BroadNet price open models: per token, cached, batch, GPU hours and flat plans, with cited prices.
How to choose an LLM API provider: a 20-point checklist
Twenty questions to ask before you pick an LLM API: pricing, limits, OpenAI compatibility, privacy, models, support and uptime, plus a scoring sheet and test plan.
How to count tokens before you send an LLM request
Estimate prompt tokens by language and model before calling an LLM API: why tokenizers differ, measured examples in five languages, and safe max_tokens margins.
How to estimate LLM API cost before you launch a feature
A step-by-step cost model for a new AI feature: users times actions times calls times tokens, with cache, reasoning, retries, rate limits and a worked monthly table.
How to evaluate an LLM before switching providers
Build a small eval set from real traffic, score it with code checks and a debiased LLM judge, and compare quality, cost and latency before you migrate.
How to handle LLM API 429 errors: backoff, jitter and limiters
429 vs 5xx, exponential backoff with full jitter, concurrency limiters and queues for LLM APIs, with Python and Node code you can copy into production.
How to run coding agents unattended overnight, safely
A practical setup for unattended coding agent runs: sandboxing, git checkpoints, task files, step limits, morning review, and flat plan sessions overnight.
How to run parallel coding agents on a flat-rate LLM API
Sub-agents, orchestrators and batch workers on unlimited DeepSeek V4.1 Flash. How many plan sessions you need, how to split them across keys, and how to cap overlap.
How to structure prompts so the prefix caches
How to lay out LLM prompts so the cached prefix stays identical: system prompt, tool schemas, documents, append-only history, plus a test that proves it.
How to transcribe call center recordings: an Arabic-ready pipeline
Split stereo calls by channel, cut speech turns, transcribe Arabic and English, redact PII and summarise each call with an LLM. A working Python pipeline with costs.
JSON mode vs json_schema: structured output that holds up
JSON mode gives valid JSON; json_schema gives your shape. How to request each on OpenAI-compatible models, validate with Pydantic, and repair bad output in a loop.
LLM API data retention compared: OpenAI, Anthropic, Gemini, Mistral
What OpenAI, Anthropic, Gemini API, Mistral and BroadNet officially say about storing API prompts and training on them, quoted from their pages in November 2026.
LLM API key security: storage, rotation and IP allow-lists
Keep LLM API keys out of code and logs, give each workload its own key, rotate on a schedule, lock keys to server IPs and revoke a leak in seconds.
LLM API pricing explained: input, cached, output and reasoning
How per-token LLM API pricing works: input, cached input, output, reasoning tokens, images and per-minute audio, with worked examples from a published rate card.
LLM API spend control: budgets, key limits and loop protection
Stop an LLM API bill from running away: prepaid balances, one key per app, IP allow-lists, usage logging, in-code budgets, loop caps and flat-price keys.
LLM API usage logging: cost per user and feature, PII redacted
Log every LLM API call with tokens, cost, latency and request ID, attribute spend to users and features, and redact PII before it is written. Python code.
LLM cost per user: unit economics for a SaaS AI feature
Work out what an AI feature costs per active user per month, why heavy users matter more than averages, and how to price SaaS tiers so the model bill stays covered.
LLM latency: TTFT vs tokens per second vs end-to-end time
What time to first token, tokens per second and end-to-end latency measure, how to time each from the client with code, and which fixes move which number.
LLM streaming explained: SSE chunks, deltas, usage and cancel
How chat-completion streaming works on the wire, how to rebuild the answer from deltas, read usage from the last chunk and cancel cleanly in Python, Node and curl.
Long context vs RAG: when 1M tokens replaces a vector DB
When a 1M-token context window can replace a vector database and when RAG still wins, compared on cost per query, latency, recall and upkeep.
Long-running agents: timeouts, retries and checkpoints that hold
Keep an LLM agent running for hours: timeouts per call, streaming to spot stalls, safe retries, idempotent tool side effects and a checkpoint after every step.
Multilingual speech-to-text API: 14 languages, one endpoint
Transcribe English, Spanish, French, Chinese, Arabic and 9 more languages through one OpenAI-compatible endpoint priced per minute, and when to use the Arabic model.
n8n AI Agent on a cheap LLM: setup, model choice and cost per run
Build n8n AI Agent workflows on a low-cost OpenAI-compatible model: which model to pick for tools, the settings that cut tokens, and the cost math per 10,000 runs.
Open-weight vs closed AI models for business: cost, control, risk
Open-weight or closed LLMs for your business? Compare cost, control, privacy, the quality gap and lock-in, with the three ways to run open models and when each wins.
OpenRouter vs a flat-rate plan for AI agents: which costs less?
OpenRouter bills per token plus a fee on credits; a flat plan bills per session. The cost math for always-on agents, OpenRouter's fees and limits, and which fits.
Reasoning tokens: why you pay for more output than you see
Reasoning models bill hidden thinking as output tokens. How to measure it, what it costs per model, and how to cut it with reasoning_effort, max_tokens and routing.
Self-hosting an LLM vs an API: the real cost and break-even
GPU rental prices from official pages, the formula for cost per 1M tokens on your own GPU, the utilization you need to beat an API, and the ops costs people forget.
Sending sensitive data to an LLM API: redact, minimise, log less
How to send customer, health or financial data to an LLM API safely: classify fields, redact with reversible placeholders, use zero retention, keep logs clean.
Speech-to-text API pricing compared: price per minute in 2026
Per-minute and per-1,000-hour prices for OpenAI, Google, AWS, Deepgram, AssemblyAI, Speechmatics, Groq and BroadNet Transcribe from official pages, plus add-ons.
Switching to an OpenAI-compatible API: a migration checklist
Changing base_url is the easy part. Model IDs, reasoning tokens, streaming usage, errors, rate limits and keys are what break. A checklist with code.
Tokens per word in Arabic vs English: why Arabic costs more
Why Arabic often uses more LLM tokens than English for the same meaning, why tokens per word misleads, and a script to measure your own ratio from the usage field.
Tool calling with open models: schemas, parallel calls, retries
Function calling on OpenAI-compatible open models: schema tips, parallel tool calls, the five ways tool calls fail, and a Python loop that validates and retries.
Use MCP servers with OpenAI-compatible models (any provider)
MCP works with any LLM: the client turns MCP tools into function calls. How to use MCP with open models in Cline, Continue, opencode, n8n or your own Python code.
Use open models in coding agents: Aider, Cline, opencode, Codex
Point Aider, Cline, Roo Code, opencode, Continue and Codex CLI at any OpenAI-compatible endpoint. The exact field names for each, plus the settings that break.
Voice notes to text for business: WhatsApp and Telegram to tickets
Turn customer voice notes from WhatsApp Business and Telegram bots into transcripts and support tickets: download, transcribe, extract fields with an LLM, route.
What "unlimited" really means in an LLM API plan
Token meters, rolling 5-hour windows, weekly caps, rate limits and concurrency. Seven questions that show whether an "unlimited" AI plan is unlimited for your agent.
What multi-agent setups really cost: per token vs flat sessions
Multi-agent systems burn several times the tokens of one agent. The session math for flat plans vs per-token billing, the hidden multipliers, and when each wins.
When a 1M-token context window is worth it (and when not)
What fits in 1,048,576 tokens, what it costs on DeepSeek V4.1 Flash, how reasoning and caching change the math, and when RAG is still the better choice.
Whisper API alternative: when to switch, and how to test one
When a hosted alternative to the OpenAI Whisper API makes sense: word error rate on your audio, languages, price per hour, limits and privacy, with test code.
Zero data retention LLM API: a 10-question checklist
What "zero data retention" should mean for an LLM API: prompts, outputs, logs, training, subprocessors and audits. Ten questions to ask before sending data.






















