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

URL: https://interfaze.ai/blog/interfaze-is-up-to-10x-cheaper-with-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](https://interfaze.ai/docs/run-tasks) 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.

| Task               | Tokens before | Tokens now | Cost before  | Cost now     | Cheaper  |
| ------------------ | ------------- | ---------- | ------------ | ------------ | -------- |
| `ocr`              | 12,568        | 1,816      | $0.04142     | $0.00381     | 10.9x    |
| `gui_detection`    | 5,231         | 1,294      | $0.01580     | $0.00208     | 7.6x     |
| `forecast`         | 10,829        | 3,178      | $0.03471     | $0.00808     | 4.3x     |
| `web_search`       | 8,294         | 3,107      | $0.02650     | $0.00837     | 3.2x     |
| `object_detection` | 5,182         | 2,705      | $0.01572     | $0.00710     | 2.2x     |
| `speech_to_text`   | 2,868         | 2,256      | $0.00740     | $0.00528     | 1.4x     |
| **All six**        | **44,972**    | **14,356** | **$0.14155** | **$0.03472** | **4.1x** |

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.

| Task               | Tokens before | Tokens now  | Cost before  | Cost now     | Cheaper  |
| ------------------ | ------------- | ----------- | ------------ | ------------ | -------- |
| `ocr`              | 26,014        | 15,262      | $0.06497     | $0.02736     | 2.4x     |
| `forecast`         | 14,911        | 7,244       | $0.04134     | $0.01465     | 2.8x     |
| `object_detection` | 9,697         | 7,159       | $0.02281     | $0.01398     | 1.6x     |
| `gui_detection`    | 24,254        | 20,335      | $0.05309     | $0.03943     | 1.3x     |
| `speech_to_text`   | 8,581         | 7,702       | $0.01662     | $0.01357     | 1.2x     |
| `web_search`       | 64,408        | 59,221      | $0.11317     | $0.09503     | 1.2x     |
| **All six**        | **147,865**   | **116,923** | **$0.31200** | **$0.20402** | **1.5x** |

`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

| Workload                            | Before  | Now    |
| ----------------------------------- | ------- | ------ |
| 10,000 invoice pages, `ocr`         | $414.20 | $38.10 |
| 10,000 `web_search` queries         | $265.00 | $83.70 |
| 10,000 `forecast` requests          | $347.10 | $80.80 |
| 10,000 screenshots, `gui_detection` | $158.00 | $20.80 |

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.

```mermaid
flowchart LR
    R1[Request 1: same PDF] --> W[Decode + specialized model run]
    W --> C[(Verified cache)]
    W --> O1[Result]
    R2[Request 2: different prompt] --> C
    R3[Request 3: different schema] --> C
    C --> O2[Result, cache hit]
```

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.

**Interfaze SDK · typescript**

```typescript
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 });
}
```

**OpenAI SDK · typescript**

```typescript
import OpenAI from "openai";

const interfaze = new OpenAI({
  apiKey: process.env.INTERFAZE_API_KEY,
  baseURL: "https://api.interfaze.ai/v1",
});

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({
    model: "interfaze-beta",
    messages: [{ role: "user", content: `${question}\n${paper}` }],
  });

  // vcache is an Interfaze addition on top of the OpenAI response shape
  console.log({
    cached: (res as unknown as { vcache: boolean }).vcache,
    tokens: res.usage?.total_tokens,
  });
}
```

**Interfaze SDK · python**

```python
from interfaze import Interfaze

interfaze = Interfaze()

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

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

for question in questions:
    res = interfaze.chat.completions.create(
        messages=[{"role": "user", "content": f"{question}\n{paper}"}],
    )

    print({"cached": res.vcache, "tokens": res.usage.total_tokens})
```

**OpenAI SDK · python**

```python
import os
from openai import OpenAI

interfaze = OpenAI(
    api_key=os.getenv("INTERFAZE_API_KEY"),
    base_url="https://api.interfaze.ai/v1",
)

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

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

for question in questions:
    res = interfaze.chat.completions.create(
        model="interfaze-beta",
        messages=[{"role": "user", "content": f"{question}\n{paper}"}],
    )

    print({"cached": res.model_extra.get("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](https://interfaze.ai/docs/handling-files).
2. **Batch several capabilities into one request.** Transcribe, translate, and classify in a single call and read the raw outputs from [precontext](https://interfaze.ai/docs/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](https://interfaze.ai/docs/lower-costs-and-improve-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](https://interfaze.ai/dashboard)
- Read the [run-task docs](https://interfaze.ai/docs/run-tasks)
- Join the [Discord](https://interfaze.ai/discord)