# AI21 API Pricing for Every Jamba Model per 1M Tokens

By Dario Espinoza-Blum · 2026-10-30 · Source: https://www.activepieces.com/blog/ai21-api-pricing-for-every-jamba-model-per-1m-tokens

---
<aside class="tldr"><p class="tldr-label">Summary</p><p>AI21 does not publicly list Jamba model prices in its docs.</p><ul><li>$10 trial credit covers roughly five million tokens of input.</li><li>Failed call retries increased billable requests by 62 percent in outage.</li></ul></aside>

## AI21 API pricing today, model by model

### Direct answer and what the API sells

Your bill is whatever you send in plus whatever comes back, multiplied by the model's rate, because AI21's API is **pay-per-token access to its Jamba models**. Three Jamba models are current:
- Mini
- Large
- Jamba2 Mini

AI21 API pricing is the per-million-token rate AI21 charges for input and output on its Jamba models, which, together with context length, batch and caching terms, and rate limits, determines what a workload costs each month.

Think of a token as a small chunk of text, roughly a short word or part of one, so a long document costs more simply because it's more chunks. That's why the rate card alone never tells you the monthly figure.

Whether you call the API from your own code or through [Activepieces](https://www.activepieces.com), which takes your own AI keys on the $20-a-month Plus plan so the model cost lands on your own provider bill, the same per-token meter runs.

### The full price table, checked 30 October 2026

Where AI21's pricing page doesn't publish a figure, or we could not confirm it, the cell says "Not listed" rather than a guess. The table below lists every current Jamba model against the figures that set your bill and your ceiling.

Read those cells as questions to put to AI21 before you commit a budget, because a missing limit is a limit you'll meet by surprise.

![Price table of Jamba models with empty cells](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/27cd856c-91f5-4d7e-8480-6281e55f27dd/ai21-api-pricing-for-every-jamba-model-per-1m-to-9c6368e4.webp)

| Model | Input $/M | Output $/M | Context window | Max output | Rate limit | Cheapest for which job |
|---|---|---|---|---|---|---|
| Jamba Mini | Not listed | Not listed | Not listed | Not listed | Not listed | Short, repetitive work such as sorting or summarizing |
| Jamba Large | Not listed | Not listed | Not listed | Not listed | Not listed | Not the cheapest for routine work; the step up when Mini's answers fall short |
| Jamba2 Mini | Not listed | Not listed | Not listed | Not listed | Not listed | Not listed |

### Which model is cheapest for which job

Start with Mini for routine work, because a smaller model usually costs less per token, and move to Large only for jobs where Mini's answers visibly fail.

Paying Large rates on every call to cover a few hard cases is **the most common way a bill drifts upward**.

Test a sample of real requests on both before you pick, and check Jamba2 Mini the same way once its price is confirmed.

## Fees and limits behind the AI21 list price

Rate limits, fine-tuning fees and enterprise terms are not listed, so those costs stay unknown until you ask; only the $10 trial credit and the batch and cache discounts are published. Here's where each of the six items stands:

- The $10 trial credit, expiring in three months: published
- Rate limits: not listed
- Batch discount: published
- Caching: published
- Fine-tuning fees: not listed
- Enterprise or private deployment terms: not listed

Take the three gaps in turn, because they are the ones that can break a budget.

### AI21 free trial credit and expiry

Three months after you get it, the $10 credit expires. Credit you haven't spent by then is gone, so start your sample tests early.

The $10 credit is good for three months, and AI21's docs point to its pricing page for per-token rates.

### AI21 API rate limits and increases

No rate limits are listed, and I found no published way to raise them. A cap decides whether a large job finishes in an afternoon or a week. **Ask for the numbers in writing before you build on the service.**

### AI21 batch, caching and discount pricing

On Jamba 1.5 Large, [CloudCostDB](https://cloudcostdb.com/ai/ai21-labs/jamba-1-5-large/) lists:
- Standard input at $2 per million tokens
- The batch rate at $1, so work that can wait overnight costs half
- The cache read rate at $0.50, a quarter of standard, so a long document you send repeatedly is cheapest when it is cached

On 100 million input tokens a month, that is $200 standard, $100 batch or $50 cached.

### AI21 enterprise and private deployment pricing

Get a written quote for enterprise or private deployment terms and for fine-tuning fees, since neither is listed. Finding the price after launch costs far more than asking before.

## Three real workload costs per month on AI21

Multiply the number of calls by the tokens going in and out, pricing each side separately, and you have the bill for any workload. You can work out yours before the first invoice.

 The longer side of the call, usually the input, sets the total.

| Workload | Calls per month | Input tokens | Output tokens | Input cost $ | Output cost $ | Monthly total $ |
|---|---|---|---|---|---|---|
| 5,000 ticket summaries (Mini) | 5,000 | 5,000 × tokens in one ticket thread | 5,000 × tokens in one summary | Input tokens ÷ 1M × Mini input price | Output tokens ÷ 1M × Mini output price | Input cost + output cost |
| Contract review (Large) | Contracts reviewed | Contracts × tokens per contract | Contracts × tokens per review | Input tokens ÷ 1M × Large input price | Output tokens ÷ 1M × Large output price | Input cost + output cost |
| Bulk classification (Mini) | Items classified | Items × tokens per item plus instructions | Items × tokens per label | Input tokens ÷ 1M × Mini input price | Output tokens ÷ 1M × Mini output price | Input cost + output cost |

### Jamba cost for 5,000 ticket summaries

When a ticket summary reads a whole conversation and writes a few sentences, input far outweighs output.

The cost is almost all in the input column, which means trimming what you send, such as dropping quoted email chains, cuts the bill more than shortening the summary would.

### Jamba cost for long contract review

This is the one row where both the volume and the rate work against you, because contracts are long and the Large model charges more per token.

If you send the full contract again for every question about it, you pay for it every time. Ask all your questions in one call, or check whether caching applies, before you scale this up.

### High-volume classification on the small model

Close to nothing: that is the output cost, since each classification call produces a one-word label.

The cost to watch is the instruction block you repeat on every call. A long set of instructions multiplied across a very large number of items can cost more than the items themselves, so keep it short.

## Hidden costs people hit with AI21 usage

Once you know where the bill leaks, those discounts and caps start to help, and it leaks in four places:
- output length
- resent context
- retries
- the hours spent wiring everything together

### Output tokens and verbose answers

Because output tokens are typically billed at a higher rate than input tokens, a chatty answer costs more than a long question.

Log the output length of a sample of calls, then ask for a fixed format or a word limit in the prompt. That's usually the cheapest fix available.

### Repeated prompt tokens on every AI21 call

Because the model remembers nothing between calls, **your instructions travel with every request**. In the Jamba Large test, a fixed prompt of about 13,900 tokens resent each time is billed as input on every call.

At 1,000 requests, that is 13.9 million tokens of repeated text.

Measure your system prompt's length once, trim it, and use caching where it applies.

### AI21 retries and failed request charges

When your code retries a failed call, you are billed again if the attempt reached the model. [PeakInfer](https://www.peakinfer.com/blog/how-failed-requests-inflate-your-bill) models an outage where 1,000 original requests trigger 400 first retries, then 160 second retries, then 64 third retries.

![Vending machine with a second coin being inserted](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/99411c81-7e53-43fd-9a59-76a9d8b1eb7f/ai21-api-pricing-for-every-jamba-model-per-1m-to-1dd7c524.webp)

![How retries inflate billed API calls in an outage](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/bb1e43d3-f1d3-4b74-a315-184a3f32d97e/ai21-api-pricing-for-every-jamba-model-per-1m-to-e1cd3fee.svg "Source: PeakInfer")

That is 1,624 billed calls for 1,000 pieces of work, or **62% more than you planned for**.

Count billed calls against completed jobs each week. Cap retries at two or three and wait longer between attempts.

### Glue work around the API

It never shows up on the invoice, but it's real labor: someone has to write the code that handles errors, trims prompts, and tracks spend.

Budget a few days of engineering time before launch, and log token counts per call from day one so you are not reconstructing them later.

## AI21 against OpenAI, Anthropic and Google on price

Only when its price per call, after any cache discount, beats a rival's is AI21 cheaper. Rivals now discount repeated input by 90 to 98 percent, so AI21 cannot compete on cache benefits alone.

<blockquote class="pull"><p>Only when its price per call, after any cache discount, beats a rival's is AI21 cheaper.</p></blockquote>

That is the bar every comparison has to clear.

Look at the cached-input discount in the table, the part of the bill that shrinks most when you resend the same instructions each call.

The rivals' discounts sit in a narrow band, so the gap between vendors comes down to list price and context, not caching.

| Model | Vendor | Discount on cached input |
|---|---|---|
| Claude Fable 5.1 | Anthropic | 98% |
| Claude Opus 5.5 | Anthropic | 95% |
| Claude Sonnet 5.5 | Anthropic | 95% |
| GPT-6.1 Sol | OpenAI | 95% |
| Gemini 4 Argon | Google | 95% |
| Claude Haiku 5.5 | Anthropic | 90% |

Source: [3AM Marketer.com](https://[3ammarketer](https://3ammarketer.com/data/model-pricing/prompt-caching)/data/model-pricing/prompt-caching).

### Small, cheap models compared

At 90 percent off cached input, Claude Haiku 5.5 has the lowest discount here, and it is [Anthropic](https://www.anthropic.com/news/claude-3-5-sonnet)'s current fast tier.

You send the most calls to a small model, so a 90 percent discount still means one tenth of the input price on every repeat. Jamba Mini has to beat that figure on its own list price to win.

### Large models compared

At 98 percent off cached input, Claude Fable 5.1 makes a long, unchanging prompt cost almost nothing to resend. Opus 5.5, Sonnet 5.5, GPT-6.1 Sol and Gemini 4 Argon all sit at 95 percent, which means buyers cannot choose between them based on caching.

If your prompts are long and repeated, Jamba Large faces a cached price one-twentieth of fresh input at four rivals, and one-fiftieth at Fable.

### When AI21 is the cheaper choice

AI21 wins where your prompts change on every call, because caching then saves you nothing and only list price counts. Where the same large prompt repeats, run both bills before committing.

![Two counters, identical folders versus different folders](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/545d6562-285d-4354-bae9-8273cb375275/ai21-api-pricing-for-every-jamba-model-per-1m-to-baa934aa.webp)

## Run recurring AI21 calls with Activepieces

If the same large prompt keeps going out, the cheapest fix is to control when it goes out and how many times.

Activepieces, an automation tool that chains steps together, does that job, with unlimited flows on every plan including the free one, and a run costs 1 credit however many steps it has.

![A workflow builder showing a five-step automation for monitoring competitor pricing changes on a weekly schedule.](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/ab62e6b3-1bda-4345-b092-87dc7a08c4ac/serp-api-pricing-plans-and-costs-2026-guide-scre-2a2af8e9.webp)

It doesn't lower AI21's price. It sits in front of the API and decides what gets sent.

In the screenshot you can see the kind of workflow this suits: a five-step flow called "Competitor Pricing Change Alert," set to run every Friday at noon UTC.

It reads a list from Google Sheets, clears a storage step, loops through each row, and scrapes a page per row.

Swap the last step for an AI21 call and you have a weekly job with a fixed rhythm instead of someone pasting prompts by hand. The point to take from it is the schedule: the bill is one run a week, not whenever someone remembers.

![Activepieces workflow builder with HTTP request step selected and its settings panel open showing method, URL, headers, and…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/9e36e973-de4a-435f-8912-12e666216b2d/self-host-mistral-ai-enterprise-deployment-guide-3f7fe28d.webp)

You reach AI21 through a generic HTTP step that posts to its API with your key, since it has no dedicated step here.

That works, but you build the request yourself. Triggers can just as easily be a form submission, a new email or a new ticket.

### Cap and log spend per workflow

Without a ceiling, a loop that misfires can send the same expensive call hundreds of times before anyone notices. Put a counter in the flow's storage and stop the run when it passes your limit.

After each call, write the model name, the input size and the output size to a sheet row. Multiply those by the list price once a month and you have your own bill, per workflow, before the invoice arrives.

![A completed flow run showing trigger and step execution with HTTP request details and success status](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/bf7801a3-7dea-4788-a83a-1d3dde0fbc59/what-actually-transfers-when-you-migrate-off-aut-3c5ad478.webp)

### Batch inputs before the API call

When calls are triggered one ticket at a time, each carries the full instructions again.

Instead, let the flow collect items for a day or a week, then send them together in one request where the model's context allows. You pay for the shared instructions once rather than per item.

Check the result against the cost log, because a batch that overruns the context window fails entirely.

## Checking your AI21 bill on Monday

Follow five steps in order, starting from the cost log you just checked, and your first AI21 bill holds no surprises. Skipping them means a month of guessing; doing them costs an afternoon and a week of patience.

1. Re-check the pricing page on signup day.
2. Run a 50-example test and pick the cheapest model that passes.
3. Set a budget alert.
4. Log tokens per call for a week.
5. Call sales only once your volume justifies it.

Each step feeds the next. The price you confirm sets what the test costs, the test picks the model, and the model sets the spending level your alert should watch.

### Re-verify the price page

Prices change. Any table in an article, this one included, is a snapshot.

Open AI21's own pricing page the day you sign up and write down the date next to each rate you rely on. If you budget from a stale number, every estimate after it's wrong by the same margin.

### Test the cheapest model first

Collect 50 real examples from your own work, not invented ones. Run them through the cheapest model, then step up only if it fails.

A pass means the output is something you would actually send or use. Paying for a larger model when a smaller one passes is the most common way a bill grows with no gain in quality.

### Measure a week of real tokens

Set the budget alert before real traffic starts, so an overrun reaches you as a message instead of an invoice. Then record the tokens in and out of every call for a week.

Expect your real prompts to run longer than your estimate, because instructions and pasted documents ride along each time. Once you have a week of data, you can multiply by your expected volume.

If that total is large enough that a discount would matter, call sales, with your own numbers in hand. Before that point, the call tells you little.

## Frequently asked questions

Here are the questions the pricing body leaves open; each answer points you to the page or test that settles it.

### Is there a free AI21 API plan?

New accounts have generally received trial credit to test with, but the amount and the models it covers can change. Check your account dashboard before you build a plan around it.

Treat the credit as a test budget. Once it runs out, calls bill at the normal rates, so find out what happens at that point before you ship anything to real users.

### Does AI21 charge for input and output tokens separately?

Yes, each is priced on its own line. Output tokens usually cost more than input tokens, so the mix matters.

A job that sends long documents and gets short answers back bills very differently from one that sends a short question and gets pages of text. Estimate both sides for your own work.

### Is AI21 cheaper than OpenAI?

It depends on the model you compare and on what you send. A lower list price can still lose if the cheaper model needs longer prompts or more retries to do the same job.

The fair test is to run the same real requests through both vendors and compare the resulting monthly bills, not the rate cards.

### Can I get a discount for committed volume?

Don't assume so from the public price list. Volume arrangements are normally negotiated with the vendor's sales team, and they depend on how much you can commit to.

If you're spending enough that a discount would matter, ask, and get the terms in writing before they go into your budget.

### How often does AI21 change its prices?

When models are added, replaced or retired, prices move, and there's no fixed schedule. Date every estimate to the day you read the pricing page, and re-check it before you renew a budget or sign a contract.

## Related reading

- [Gemini API Pricing 2026: Every Model, $1.25 per 1M Tokens](https://www.activepieces.com/blog/gemini-api-pricing-2026-every-model-tokens-limits)
- [DeepSeek API Pricing 2026: Cost per 1M Tokens](https://www.activepieces.com/blog/deepseek-api-pricing-2026-cost-per-1m-tokens)
- [Claude API Pricing 2026: Rates for Every Model](https://www.activepieces.com/blog/claude-api-pricing-2026-rates-for-every-model)

## References

- [CloudCostDB](https://cloudcostdb.com/ai/ai21-labs/jamba-1-5-large/)
- [PeakInfer](https://www.peakinfer.com/blog/how-failed-requests-inflate-your-bill)
- [3AM Marketer](https://3ammarketer.com/data/model-pricing/prompt-caching)
