> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mixpeek.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Billing & Pricing

> Three questions set your price: what kind of files, how much content, and what you want to search by — tiers include a monthly usage pool

## How pricing works

Your price is the answer to three questions, in this order:

1. **What kind of files?** Video, image, audio, PDF/document, text, or web pages — the modality.
2. **How much content?** Each file type counts in its honest natural unit: images per file, video and audio per minute, PDFs per page, text per token, web per crawled page.
3. **What do you want to search by?** Visual similarity, faces, on-screen text, document layout, transcripts, ... — these plain-language capabilities are **[features](https://docs.mixpeek.com/docs/processing/features.md)**.

For each file type: **price = amount × (base rate + the search-by features you enable)**. Each tier is a flat monthly fee that includes a usage pool; anything beyond the pool bills at the same rate card.

**Worked example** — 100 videos averaging 2 minutes each, searchable by what's on screen (base video search) plus who appears (faces):

1. What kind of files: video → bills per minute
2. How much: 100 videos × 2 min = **200 minutes**
3. Search by: video search (base, $0.05/min) + faces (+$0.10/min)

200 min × ($0.05 + $0.10) = \*\*$30**. On Scale, the $100 monthly pool covers it entirely; on Build, $10 comes out of the pool and $20 bills as overage.

Everything is in dollars — rates, usage, invoices, and quotes are dollar-denominated end to end. Quote any planned ingestion before you run it with the [estimate endpoint](#estimate-before-you-run); it uses the same rating engine that bills you.

For current numbers, see the [pricing page](https://mixpeek.com/pricing). Manage your plan and payment method in [Studio Billing](https://studio.mixpeek.com/billing).

> [!NOTE]
>
> Under the hood, each feature maps to a feature extractor — that deeper layer (which extractor implements a feature, extractor options, bring-your-own extractors) is documented in [Features](https://docs.mixpeek.com/docs/processing/features.md#how-this-relates-to-extractors). You never need it to understand your bill.

***

## Plans

> [!NOTE]
>
> **Plan gating:** `GET /v1/organizations` returns `requires_plan`. When `true`,
> the workspace must pick a plan before creating namespaces or running billable
> work — gated endpoints return `403 PlanRequiredError` with a link to
> [choose a plan](https://studio.mixpeek.com/signup/plan). There is no separate
> "tier" endpoint: `account_type`, `credit_count`, and `requires_plan` on the
> organization are the capability surface.

Each tier is a **flat monthly fee that includes a usage pool** — a dollar allowance you can spend on any mix of modalities and features. Only usage beyond the pool bills as overage, at the same rate card.

| | Build | Scale | Enterprise |
| - | - | - | - |
| **Monthly price** | \$25 | \$250 | Custom |
| **Included usage pool** | \$10 | \$100 | Custom |
| **Pool buys, e.g.** | \~6,600 images **or** 200 video minutes **or** \~6,600 pages | \~66,000 images **or** 2,000 video minutes **or** \~66,000 pages | — |
| **Overage** | Rate card | Rate card | Contract |
| **Custom extractors** | Included | Included | Included |
| **Support** | Email | Priority + private Slack | Dedicated |

The pool is **fungible** — it isn't a per-modality cap. The natural-unit equivalents above are just the pool divided by each base rate, so you can compare tiers at a glance. Spend it on whatever mix you actually ingest.

> [!NOTE]
>
> Enterprise runs on dedicated single-tenant infrastructure with custom contracts — see [Single Tenant](https://docs.mixpeek.com/docs/resources/single-tenant.md) or [contact sales](https://mixpeek.com/contact).

***

## The rate card

**The API is the source of truth for rates.** `GET /v1/billing/pricing` is public (no auth) and returns the live rate card — the same payload that studio, the homepage, and the billing engine read, so displayed numbers can never disagree with billed numbers:

```bash theme={null}
curl "https://api.mixpeek.com/v1/billing/pricing"
```

```json theme={null}
{
  "pricing_model": "v2",
  "currency": "usd",
  "placeholder_rates": false,
  "modalities": [
    {
      "modality": "video",
      "unit": "minute",
      "unit_display": "per minute",
      "base": { "key": "video_search", "name": "Video search (scene embeddings)", "rate_usd": 0.05, "per": 1 },
      "addons": [
        { "key": "faces", "name": "Face detection + identity", "kind": "addon", "rate_usd": 0.10, "per": 1 },
        { "key": "onscreen_text", "name": "On-screen text (video OCR)", "kind": "addon", "rate_usd": 0.10, "per": 1 },
        { "key": "audio_fingerprint", "name": "Audio fingerprint (in video)", "kind": "addon", "rate_usd": 0.01, "per": 1 },
        { "key": "multimodal_understanding", "kind": "external", "pricing_note": "usage-based (external inference)" },
        { "key": "clustering", "kind": "included", "pricing_note": "included — no additional charge" },
        { "key": "taxonomy_enrichment", "kind": "included", "pricing_note": "included — no additional charge" }
      ]
    }
  ],
  "usage_pools": {
    "build": {
      "flat_monthly_usd": 25.0,
      "usage_pool_usd": 10.0,
      "pool_equivalents": { "images": 6667, "video_minutes": 200, "pages": 6667, "text_tokens": 5000000 }
    }
  },
  "mvs_usage_rates": {
    "vectors_stored_per_million_month_usd": 1.56,
    "storage_per_gb_month_usd": 0.023,
    "queries_per_million_usd": 2.0,
    "writes_per_million_usd": 2.0
  },
  "reads": { "overage_usd_per_1m_queries": 2.0, "image_query_embedding_usd": 0.001 },
  "full_res_multiplier": 2.0
}
```

Response abbreviated — the live payload covers all six modalities and every tier. How to read it:

* **`modalities[].base`** — the per-unit rate for making that modality searchable. Creating any collection for a modality gets you its base feature.
* **`modalities[].addons`** — features you opt into, priced per the same unit. `kind: "external"` rows are backed by external LLM inference and priced per unit, at a rate set from the measured upstream cost. `kind: "included"` rows (clustering, taxonomy enrichment) cost nothing extra.
* **`usage_pools`** — each tier's flat fee and included dollar pool, with derived natural-unit equivalents.
* **`placeholder_rates`** — `false` means the rates are live and billable. (The nested `v2` object in the payload is a deprecated alias of these same top-level keys and will be removed.)

> [!TIP]
>
> Don't hardcode rates into your own tooling — read them from `GET /v1/billing/pricing`, or quote concrete workloads with the [estimate endpoint](#estimate-before-you-run).

### Price a workload before you sign up

The rate card needs no account, so you can cost a workload from code before choosing a plan. This prices 6,000 video minutes a month with face search and on-screen text:

```python theme={null}
import requests

card = requests.get("https://api.mixpeek.com/v1/billing/pricing").json()
video = next(m for m in card["modalities"] if m["modality"] == "video")
rates = {video["base"]["key"]: video["base"]}
rates.update({a["key"]: a for a in video["addons"]})

minutes = 6000
wanted = [video["base"]["key"], "faces", "onscreen_text"]
usd = sum(minutes / rates[k]["per"] * rates[k]["rate_usd"] for k in wanted if k in rates)
print(f"~${usd:,.2f} per month before your plan's included usage")
```

Add-on keys differ per modality; print `video["addons"]` to see them. The [estimate endpoint](#estimate-before-you-run) returns the same numbers itemized against your plan's remaining pool, and it needs an API key on an active plan.

### How a batch is priced

When you submit a batch, each object bills as: **modality units x (base rate + enabled add-on rates)**.

Example at the rates shown above: a 10-minute video in a collection with `faces` and `onscreen_text` enabled bills 10 min x ($0.05 + $0.10 + $0.10) = **$2.50\*\*.

* **Measured units** — video/audio minutes come from measured duration (not file size), pages from actual page counts. Anything estimated at submit is trued up at batch completion, in both directions.
* **Batch minimum** — batches bill at least **\$0.01**.
* **Normalization included** — content is normalized once at ingest (video to 720p mezzanine, images capped, audio to 16kHz mono). Originals stay untouched in your bucket. Collections that opt out with `full_res: true` bill at a **2x multiplier**. See [full resolution opt-out](https://docs.mixpeek.com/docs/processing/features.md#full-resolution-opt-out).
* **Deduplication** — re-ingesting content Mixpeek has already processed (same content hash) skips extraction rather than re-billing full processing.

### Storage

Storage bills at two rates from `mvs_usage_rates`: **$1.56 per 1M vectors stored per month** (`vectors_stored_per_million_month_usd`) plus **$0.023 per GB-month** (`storage_per_gb_month_usd`).

### Reads (queries)

Reads bill at **\$2 per 1M queries** (`reads.overage_usd_per_1m_queries`).

A saved retriever run with an image as its query also embeds that image once, billed as one embedding at **\$0.001** (`reads.image_query_embedding_usd`) and listed as a `retriever_query_embedding` line in your usage. A query that sends a precomputed vector embeds nothing and is not billed.

***

## Estimate before you run

`POST /v1/organizations/billing/estimate` quotes planned ingestion — same rating engine, same rate card, so the quote matches the eventual charge:

```bash theme={null}
curl -X POST "https://api.mixpeek.com/v1/organizations/billing/estimate" \
  -H "Authorization: Bearer $MIXPEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "items": [{ "mime_type": "video/mp4", "minutes": 42 }],
    "features": ["faces"]
  }'
```

The response itemizes dollars per (modality, feature), reports how much falls inside your remaining usage pool, and what would bill as overage. Full request/response details in [Features → Estimate](https://docs.mixpeek.com/docs/processing/features.md#estimate-before-you-run).

### Quote a namespace

Send a namespace manifest, the files each bucket will hold, and your queries per month. The route prices the manifest the way batch submit charges it, collection by collection, before anything runs. The manifest can be a template's, one you wrote, or one from `POST /v1/manifest/generate`.

```bash cURL theme={null}
jq -n --rawfile manifest namespace.yaml '{
    manifest: $manifest,
    inventory: {"product-photos": {objects: 200, images: 200}},
    queries_per_month: 10000
  }' |
curl -X POST "https://api.mixpeek.com/v1/organizations/billing/estimate" \
  -H "Authorization: Bearer $MIXPEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d @-
```

```python Python theme={null}
import os, requests

quote = requests.post(
    "https://api.mixpeek.com/v1/organizations/billing/estimate",
    headers={"Authorization": f"Bearer {os.environ['MIXPEEK_API_KEY']}"},
    json={
        "manifest": open("namespace.yaml").read(),
        "inventory": {"product-photos": {"objects": 200, "images": 200}},
        "queries_per_month": 10000,
    },
).json()["manifest_quote"]
print(quote["index_usd"], quote["monthly_usd"])
```

```javascript JavaScript theme={null}
import { readFileSync } from "node:fs";

const res = await fetch("https://api.mixpeek.com/v1/organizations/billing/estimate", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.MIXPEEK_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    manifest: readFileSync("namespace.yaml", "utf8"),
    inventory: { "product-photos": { objects: 200, images: 200 } },
    queries_per_month: 10000,
  }),
});
const { manifest_quote } = await res.json();
console.log(manifest_quote.index_usd, manifest_quote.monthly_usd);
```

`inventory` takes, per bucket name in the manifest: `objects`, `videos`, `minutes`, `audio_minutes`, `images`, `pages` and `tokens`. A bucket you leave out is quoted at zero files. A bucket the manifest does not declare returns a 422 that names it.

The answer is in `manifest_quote`. This one is for 200 photos on `multimodal_extractor`, from a real run:

```json theme={null}
{
  "index_usd": 0.4,
  "monthly_usd": 0.020312,
  "storage_usd": 0.000312,
  "queries_usd": 0.02,
  "unit_prices": [
    {"modality": "image", "feature": "image_search", "rate_usd": 1.5, "per": 1000},
    {"modality": "image", "feature": "multimodal_understanding", "rate_usd": 0.5, "per": 1000}
  ],
  "unpriced_collections": []
}
```

* `index_usd` is what indexing those files is charged, once. The batch for those 200 photos was charged \$0.40.
* `monthly_usd` is storage for the documents and vectors the files produce, plus your queries.
* `unit_prices` is what each file you add is charged.
* `collections` (not shown) breaks each figure down per collection. A collection whose extractor has no rate-card price is listed in `unpriced_collections` with the reason, never priced at \$0.

***

## Tracking usage

Current-period usage is available in [Studio Billing](https://studio.mixpeek.com/billing) and via the [usage API](https://docs.mixpeek.com/docs/api-reference/organization-billing/get-current-usage.md). Usage reports break down dollars by modality and feature:

* units consumed per modality (minutes, images, pages, tokens) and per feature
* storage GB-month and reads
* pool consumption, overage, and the period's total in dollars

You can set spending caps to limit overage through [Studio Billing](https://studio.mixpeek.com/billing) or the [spending caps API](https://docs.mixpeek.com/docs/api-reference/organization-billing/get-spending-caps.md).

***

## How billing works

**1. Sign up and choose a plan**

Create an account at [studio.mixpeek.com](https://studio.mixpeek.com). Upgrade to Build or Scale from the billing page.

**2. Add a payment method**

Paid plans require a card on file via Stripe. Add or update your card in [Studio Billing](https://studio.mixpeek.com/billing) or through the [payment method API](https://docs.mixpeek.com/docs/api-reference/organization-billing/setup-payment-method.md).

**3. Use Mixpeek**

Your usage pool is available immediately and resets each cycle. Usage is metered continuously in dollars and visible in the dashboard.

**4. Receive your invoice**

Stripe generates a monthly invoice: your flat plan fee plus any overage, itemized by modality and feature. Invoices are in [Studio Billing](https://studio.mixpeek.com/billing) and via the [invoices API](https://docs.mixpeek.com/docs/api-reference/organization-billing/list-invoices.md).

***

## MVS Standalone

Using Mixpeek's vector store with your own embeddings (no extraction)? MVS bills separately. You pay the plan's flat monthly fee, plus $1.56 per 1M vectors stored per month, $0.023 per GB-month, and \$2 per 1M queries or writes. See the live `mvs_plans` and `mvs_usage_rates` in `GET /v1/billing/pricing` and the [MVS overview](https://docs.mixpeek.com/docs/vector-store/overview.md).

***

## FAQ

> [accordion] What happened to credits?
>
> Credits are gone as a customer-facing concept — every surface (rates, usage, invoices, quotes) is dollar-denominated. If you see a legacy `credits` field in an older API response, it's an internal ledger unit worth \$0.001 (a milli-dollar); the dollar fields alongside it are canonical.

> [accordion] Can the quote and the charge disagree?
>
> No. The estimate endpoint and the metering pipeline call the same rating engine against the same rate card. Estimated units (e.g. duration unknown at submit) are trued up from measured values at batch completion — in both directions.

> [accordion] Is the usage pool a per-modality cap?
>
> No. It's a fungible dollar pool — the natural-unit equivalents shown on tier cards are illustrations (pool ÷ base rate), not limits. Spend it on any mix of modalities and features.

> [accordion] Do unused pool dollars roll over?
>
> No. The usage pool resets at the start of each billing cycle.

> [accordion] Can I switch plans mid-cycle?
>
> Yes. Upgrades take effect immediately and are prorated. Downgrades take effect at the start of the next billing cycle.

> [accordion] How are LLM-backed features priced?
>
> Features marked `kind: "external"` (e.g. `multimodal_understanding`) are backed by external LLM inference. They are priced per unit (per image, per minute, per page) at a rate set from the measured upstream cost, so a quote for them is known before anything runs. The pricing payload flags them with a `pricing_note`.

> [accordion] How are custom extractors priced?
>
> A `custom:<plugin>` feature derives its per-unit rate from the compute profile the plugin declares — the same machinery that prices native features. Quote it like anything else via the estimate endpoint.

> [accordion] What happens when I exceed caps?
>
> Requests that exceed hard resource caps return `403` with type `QuotaExceededError` and an `upgrade_plan` hint. Overage within your plan simply bills at the rate card — no interruption.

> [accordion] What payment methods does Mixpeek accept?
>
> All major credit and debit cards via Stripe. Enterprise customers can pay by invoice with net-30 terms.

> [accordion] Is there an annual billing option?
>
> Annual billing is available for Scale and Enterprise. Contact sales for details.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.