Interfaze is up to 10x cheaper with better token efficiency and caching

The same OCR request that cost $0.041 last week now costs $0.0038, and you don't have to change a line of code.

Two things got us there:

• Model efficiency allowing for fewer tokens to be produced and counted.
• Similar or repeated task tokens are not cached and not charged again.

What changed

Interfaze is a mix of specialized architectures merged into a single model. Since not all models are created equal, the tokens produced may not always be used fully especially when there's an overlap in different tasks.

We took the time to standardize each output, cleaning up unused tokens and making sure we only count exactly what's been used to produce the output.

While prices per million tokens stay the same, each request now cost less since we're producing less tokens and counting a lower number of tokens too.

Token efficiency in run-task mode

Run-task mode runs one built-in capability without activating the full model. It is where most of the savings landed.

Every row below is the same request measured before and after the change.

The samples: a one page invoice image for ocr, a full Wikipedia screenshot for gui_detection, a 12 point daily series for forecast, one search query for web_search, a construction site photo for object_detection, and a 52 second WAV for speech_to_text.

Token efficiency in full model requests

Running the full model allowing it to use multiple capabilities at once, the model is able to produce more tokens and is a lot more flexible in how it can be used.

web_search and gui_detection produce the largest results, which is why their conversational totals stay high. The result gets passed back into the model, and there is no way around paying for those tokens once.

If you only need the raw output, use run-task mode and skip the second pass entirely.

What this looks like at volume

A caveat on how to read all of this. Each figure is a single sample per capability, measured on a first call with the cache empty, so treat the ratios as representative rather than precise averages.

Caching for repeated work on the same file

Most document workloads are not one request per file. You extract fields, then re-run with a different schema, then ask a follow up question, all against the same PDF.

Interfaze now caches the expensive part of that first pass. Repeated requests on the same file or a very similar prompt reuse it instead of redoing the decode and specialized model run.

Running multiple requests against the same file is roughly 10x cheaper this way. Caching is on by default and cached outputs are not charged again, so there is no flag to set and no separate cache bill.

import { Interfaze } from "interfaze";

const interfaze = new Interfaze();

const paper = "https://arxiv.org/pdf/2602.04101";

const questions = [
  "List the authors of this paper.",
  "Summarize the methodology in three bullet points.",
  "Extract every table caption.",
];

for (const question of questions) {
  const res = await interfaze.chat.completions.create({
    messages: [{ role: "user", content: `${question}\n${paper}` }],
  });

  // false on the first request, true on the ones after it
  console.log({ cached: res.vcache, tokens: res.usage?.total_tokens });
}

One thing worth knowing: cache hits depend on the file being addressable the same way each time. Pass a stable URL rather than re-uploading the same bytes as base64 on every call and you will hit the cache far more often.

Getting to the cheapest path

The changes above are automatic, but a few habits compound on top of them.

1. Pass files as URLs, not base64. Faster, cheaper, and it makes the cache work for you. See handling files.
2. Batch several capabilities into one request. Transcribe, translate, and classify in a single call and read the raw outputs from precontext instead of paying for three round trips.
3. Use structured outputs instead of describing a schema in the prompt. A JSON Schema pasted into a prompt makes the model retry until it gets the shape right, and you pay for every retry.
4. Use run-task mode when you're only interested in raw output. Raw fixed structured data output, up to 10.9x on OCR.

More patterns in lowering costs and improving performance.

Takeaway

• Run-task requests got 1.4x to 10.9x cheaper, with OCR seeing the largest drop.
• Full model requests got 1.2x to 2.8x cheaper, since the model still has to read the tool result.
• Repeated requests on one file are roughly 10x cheaper with caching, which is on by default.
• Per token pricing did not change. You are billed fewer tokens for identical work.

Nothing here needs a migration, an upgrade, or a new parameter. Your existing calls just got cheaper.

• Start building in the dashboard
• Read the run-task docs
• Join the Discord