Skip to content

Changelog

Product updates, model releases, and platform improvements.

November 2026

Cost calculator for a month of agent traffic

You can now price a month of input and output tokens across a curated set of models, with open models beside Claude Sonnet 5.5, on a public page that needs no account.

Your bill depends on how many input and output tokens you send, so the comparison that helps is one workload priced across many models, before you pick one. apertis.ai/calculator takes two monthly token volumes and prices every model in its tables against them at once, with open models next to Claude Sonnet 5.5 as the reference. No account is needed.

To start, open the page and set the two volumes, or pick a preset. An agent can read the rates as Markdown at https://apertis.ai/calculator.md.

Set your workload

The calculator's workload controls: four presets with Team workloads selected, and sliders with number boxes for 100M input and 40M output tokens per month
FieldUnitRangeDefault
Input tokensthousands of tokens per month10 to 1,000,000 (10K to 1B tokens)100,000 (100M)
Output tokensthousands of tokens per month10 to 1,000,00040,000 (40M)

Each field has a slider and a number box. The slider is logarithmic and snaps to three significant figures. A typed value is rounded to a whole number and clamped to the range.

Four presets fill both fields (input / output, in K tokens): Occasional agent 500 / 200, Daily coding 5,000 / 2,000, Parallel agents 25,000 / 10,000, Team workloads 100,000 / 40,000. The page opens on Team workloads. There is no cached-token field.

See how a month is computed

monthly = input_rate x (input_K / 1000) + output_rate x (output_K / 1000)

Rates are USD per 1M tokens. At the default workload, a model at $2.00 in and $10.00 out costs 100 x 2.00 + 40 x 10.00 = $600.00.

Compare open models with Claude

One table prices one flagship per open-model vendor on the same workload, at Apertis list rates, against Claude Sonnet 5.5 as the reference.

The Open models next to Claude table at the default workload: Claude Sonnet 5.5 at $600.00 as the reference row, then MiniMax M3, DeepSeek V4 Pro, GLM 5.3, Qwen and Kimi with their monthly cost and the difference from Claude
VendorModel ID
GLMglm-5.3
Kimikimi-k3.1-pro
DeepSeekdeepseek-v4-pro
MiniMaxminimax-m3
Qwenqwen3.8-2.4t-a95b

Columns: input and output rate per 1M, monthly cost, and the difference from Claude in dollars and as a share. The Claude row is first, then the open models, cheapest first. A vendor whose flagship is not in the catalog is shown as not listed; it is never replaced by another model.

Compare Apertis totals with the market list rate

A second table holds up to seven chat models, one per provider (the provider's newest), with OpenAI, Anthropic and Google always included when they qualify. Free and per-request models are left out. Rows are sorted by Apertis total, cheapest first.

Beside the Apertis total, a Market list column prices the same workload at the model's public list rate, and a Difference column gives the Apertis total minus the market total. Under half a cent it reads Same. The line under the table reads "Both read YYYY-MM-DD": the UTC date the page read the Apertis catalog and the market source, one date for both.

When the market source does not answer, the Market list column reads Not available, with a note that this does not mean the market has no priced models. The Apertis column still renders.

Know what bonus credit does to a total

Every total is a list price. Bonus credit on an Add Credits purchase is added on top of what you buy and never changes a total in these tables; the page shows the current schedule.

Read the rates from an agent

GET /calculator.md returns text/markdown; charset=utf-8. It lists per-1M rates for each model in both tables, the formula and the read date. It takes no workload and prints no monthly totals.

State and limits

The inputs are not in the URL: there are no query parameters, and a reload returns to the default workload.

The page states its own limit: it is a reference estimate. A bill depends on the current access option, included usage, overflow terms, the routed provider and actual cache behavior. It is not a quote or a guaranteed savings calculation.

Read update

Open models, verified in public

You can now see which model and which source answered an open-model request, then match it to a dated public report of checks. Three response headers name the answer.

An open model can be served by more than one source, so when an answer looks off, the first question is which source gave it.

An answer for an open model carries three headers that name the model and the source that answered. They are written before the first byte, so a streamed response has them too. The report at apertis.ai/verification lists what we checked for each model on each source, so you can read the result for the source that served you.

To start, send a request and read the headers:

$ curl -i https://api.apertis.ai/v1/chat/completions \
    -H "Authorization: Bearer $APERTIS_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"model":"glm-4.7","messages":[{"role":"user","content":"Say ok."}],"max_tokens":16}'

HTTP/2 200
x-apertis-served-model: glm-4.7
x-apertis-source: aggregator-a
x-apertis-source-type: aggregator

The header values above are an example; your response names the source that answered your request. To match it, read the model and the label, find the row with that model and that label in the results table, then read its checks and its run date.

Read the receipt headers

The report's table of the three receipt headers, X-Apertis-Served-Model, X-Apertis-Source and X-Apertis-Source-Type, with their values and meanings
HeaderValue
X-Apertis-Served-ModelThe public model id that answered, after any fallback.
X-Apertis-SourceA source label from the report's Source column; undisclosed when the source is not in the report; apertis-cache when the answer came from the Apertis cache.
X-Apertis-Source-Typemaker, aggregator, cache or unregistered.

They appear on /v1/chat/completions and /v1/messages, and are listed in Access-Control-Expose-Headers, so browser code can read them. Claude models carry no receipt, and neither does a response with no answer in it, such as an error.

Find your source in the report

An agent can read the same report as Markdown at apertis.ai/verification.md. Both render one generated data file; no result is typed by hand.

One row is one model on one source for one run. A row carries the model, the source label, the source type, the run date, and the five results below. The first publication has two rows for glm-4.7, run on 2026-11-08.

The results table of the verification report: two glm-4.7 rows from two anonymous sources, one whose input token count matches the tokenizer reference and one whose count differs

Sources appear under anonymous labels such as aggregator-a. A model maker's name appears only where that maker's own API is the source and its terms allow it. In this publication every source is an aggregator or reseller, so none is named and no maker's own endpoint is measured. The reference is the maker's published tokenizer, not a response from the maker.

Know what each check measures

CheckHow it is runWhat the row shows
Input token countOne fixed prompt, printed in full on the page, mixing scripts, emoji, code and numbers. usage.prompt_tokens is read from the source and compared with the count from the maker's published tokenizer at a pinned revision.Within tolerance when within 2 tokens or 3% of the reference, whichever is larger. Outside it, the row says the count differs and is not shown as verified. A model with no pinned reference shows its count and no verdict.
Tool callOne declared function, a second turn with the tool's result.Pass or fail, the number of calls in the run, and the share of arguments that fit the declared schema.
CacheThe same prompt of about 7,000 tokens, sent three times, two seconds apart. Calls two and three must report cached tokens; a prompt with another first line must report none.Pass or fail, and the share of the third call's prompt read from cache.
Time to first tokenFor each streamed request that returned 200, the time from sending to the first chunk.Median (p50) and 90th percentile (p90), or not measured.
AvailabilityCalls that returned 200, divided by calls that returned 200, a 5xx or a 408. A 429 is counted separately.The ratio, the number of calls and the number of server errors.

In the first publication one source matches the reference (86 tokens against 86) and one does not (83 against 86). A count that differs means the source wrapped or split the same prompt differently, for example with another chat template. It does not say which model answered.

Rerun the fingerprint yourself

Send the report's fingerprint prompt with max_tokens set to 16 and compare usage.prompt_tokens with the reference. The page lists, per model, the tokenizer repository, the pinned revision and the chat template with its SHA-256 (for glm-4.7: zai-org/GLM-4.7, 86 tokens), and a request block ready to copy.

What a row does not tell you

Each row is a snapshot of one run on the date shown; a source can change afterwards. A row describes one model on one source and says nothing about other models on that source. The report is regenerated when a model or a source is added, and each publication is a dated snapshot.

Read update

Apertis skills for your coding agent

You can now give Claude Code, Cursor, Codex and other agents four Apertis skills from one public repository: a verified first call, an API reference, a model picker and an OpenAI migration.

With four skills installed, your coding agent walks you to a verified first call, answers from an API reference, picks a model for a task, and moves an OpenAI SDK codebase over to Apertis. One command installs them from apertis-ai/apertis-skills, and they work with Claude Code, Cursor, Codex and other agents.

Install the skills

Both routes install the same four skills.

ToolCommand
Any agent that supports the Agent Skills format (Cursor, GitHub Copilot, Codex, Gemini CLI and others)npx skills add apertis-ai/apertis-skills
Claude Code/plugin marketplace add apertis-ai/apertis-skills, then /plugin install apertis-skills@apertis-skills

To see what the repository holds before installing anything, add --list:

npx skills add apertis-ai/apertis-skills --list
Terminal output of npx skills add with the list flag, showing the four Apertis skills and their descriptions

The Claude Code route works because the repository publishes a plugin marketplace named apertis-skills with one plugin of the same name.

Pick the skill for the job

Each skill is a SKILL.md under skills/<name>/.

SkillWhat it makes the agent able to doTriggers on
apertis-quickstartWalk you to a verified first call: check APERTIS_API_KEY, call https://api.apertis.ai/v1/chat/completions, confirm that :web returns a top-level web_sources array, and diagnose a 401, a wrong base URL, model_not_found, empty web_sources, a 429 and quota errors.Getting started, setting up, a first call, a first call that fails
apertis-apiAnswer from a reference of auth, the documented endpoints, model families, the :web suffix and the Vercel AI SDK provider @apertis/ai-sdk-provider.Calling or integrating the Apertis API
apertis-model-pickerRecommend a model by task (coding, long context, fast chat, web search, vision, reasoning, cost) and call GET /v1/recommend for a current pick.Which model to use for a task
apertis-migrateMove an OpenAI SDK codebase over: set base_url to https://api.apertis.ai/v1, rename OPENAI_API_KEY to APERTIS_API_KEY, update .env.example. Covers Python, TypeScript, curl, LangChain and the Vercel AI SDK.Switching from OpenAI to Apertis

All four are at the same version, which each SKILL.md states in its front matter:

Terminal output of grep over the four SKILL.md files, each reporting version 1.4.0

Make your first call with the quickstart skill

The quickstart skill makes two real requests with your own key: a chat completion with max_tokens 32, then a :web request with max_tokens 256. It is written to use only your key, to stay read-only, and never to print the full key. It cannot create a key for you; sign up at apertis.ai, open API Keys, and export it:

export APERTIS_API_KEY="sk-..."

Pay-as-you-go keys start with sk-, subscription keys with sk-sub_. Prompts that activate the skill include "Set up Apertis" and "Make my first Apertis API call."

Read update

Your dashboard, rebuilt

Starting today your dashboard is one Settings page with eleven tabs that answer at once, with usage by model and API key, plus latency and first-token times for your requests.

When a bill or a slow response raises a question, the answer is one click away: open the request in Logs to see latency, time to first token, tokens by kind with their cost, and the request ID your client already received. Your account is now one Settings page whose tabs answer a click at once, and a panel whose data fails to load says so instead of showing a zero.

Every request, with the numbers that explain it

Logs lists each request and each billing event. Open a row and the drawer answers the questions a bill or a slow response raises:

A streamed Claude Sonnet 4.6 request open in the Logs drawer: what was charged and what paid for it, latency and time to first token beside the model's median, output speed, and tokens by kind with a cost for each
FieldWhat it tells you
Charged, Paid fromthe amount, and whether it came out of included plan quota, on-demand credit or credits
Latencytotal time of the request, beside this model's median for the period: "35% faster (median 16.5 s)"
TTFTtime to first token, counting reasoning, for a streamed response, with the same comparison
Output speedtokens per second, for a streamed response
Tokens by kindinput that was not cached, cache read, cache write, output and reasoning tokens, and the share of the input that was read from the cache
Cost per kindshown when the catalogue prices every kind the request used: the charge split in proportion to list prices. The total is always what was charged
Stopped becausethe finish reason in words: it finished, it hit the length limit, it called a tool
Plan multiplieron a subscription request, the multiplier the plan applies to this model
Applicationthe client that sent the request
Request IDthe id your client received, and the one to quote to support

The request ID is the one your client already has. Every API response carries it in the X-Apertis-Request-Id header:

curl -si https://api.apertis.ai/v1/chat/completions \
  -H "Authorization: Bearer $APERTIS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-5.4","messages":[{"role":"user","content":"ping"}]}' \
  | grep -i x-apertis-request-id

Log that header in your application and you can paste it into the Logs search box to land on the exact request: its model, tokens, cost and timing.

Other details that save time:

  • Every filter lives in the URL. Range, comparison, interval, model, key, payer, event and search are query parameters, so a filtered view can be bookmarked or sent to a teammate, and it survives a reload. An open row is linkable too.
  • Keyboard. j and k, or the arrow keys, walk through rows without closing the drawer.
  • Filter by API key to see what one key did, by who paid to separate included quota from on-demand spend, and by application.

See latency and first-token time, per model and per day

Above the list, the overview charts the same window by credits, requests, latency or TTFT, and compares it with the previous period or the same days last month.

The Logs overview switched to Latency: one bar per day over the last 30 days, with the request list below it

You can show latency and TTFT as an average or a median. The median is read from a histogram of every request in the window, not from a sample, so one slow outlier does not move it. Bars can be hourly for a window of a day or two, and daily or weekly beyond that.

Read your usage and limits

Usage & Limits shows what you used and what you were charged.

Usage & Limits: the monthly limit meter, spend and requests for the last 30 days, and usage by model
  • Ranges: the last 7, 30 or 90 days, or a custom range inside the last 90 days.
  • Spend is what you were charged, not a list-price estimate. A plan account sees included quota and on-demand credit as separate meters.
  • Model Usages sorts by spend, requests, input or output tokens, with a provider filter.
  • CSV export returns one row per model per day: date, model_id, model_name, provider, requests, quota, spend_usd (1 USD is 1,000,000 quota units).
  • Fresh without waiting. The usage read is keyed to a version that moves with every request you make, so a request you just sent shows up on the next view, not after a cache timer.

A failed read says so

A dashboard that draws $0 when its data failed to load is worse than no dashboard: the zero looks like real usage. Each panel now has three distinct states: loading, loaded, and failed.

When a read failsWhat you see
Usage, on Overview and Usage & Limits"Usage couldn't be loaded." with Retry and a request ID
Balance, plan, logs, creditsthat panel's own message; the other panels stay usable
Too many requests"Too many requests in a short time"
After you change a settingthe last good value stays on screen until a newer one replaces it
CSV exportan error response, never an empty file that looks like a month with no usage

One page, and it answers at once

Everything about your account is at apertis.ai/setting: Overview, Usage & Limits, Activity, Logs, API Keys, Credits, Billing, Preferences, Security, Subscription and Plan Models.

A tab click no longer waits for data. The page frame and the tab's own structure draw first and the numbers stream in. In our test rig, with 300 ms added to every API call, the first visible change after a click went from 651 to 1,031 ms down to 3 to 9 ms. Returning to a tab within 30 seconds redraws it with no request at all; after that, one small version check decides whether anything needs refetching.

Old links keep working:

Old URLNow opens
/tokenSettings, API Keys
/token/edit/<id>API Keys, with that key open
/topupCredits
/logLogs
/subscription-dashboardSubscription, or Plan Models
/user/editOverview

A signed-out visitor is sent to sign in and returned to the same tab with the same filters.

Read update

Leaked-key protection

Starting today, a key whose spend stops looking like its own history is held to a lower request rate, and an exposed key can be revoked in one step with a notice to its owner.

A stolen key now costs you less while you look into it, and there is nothing to turn on: every key is measured against its own history. The same release lets you revoke a key for good in one step, check a new key's format offline, and cap the worst case in advance with per-key limits.

A key that stops looking like itself is slowed

A leaked key is usually found by the bill. Apertis now measures each key's spend against that key's own history and reacts before the bill arrives. A key is flagged when:

  • its spend rate jumps far above its own recent peak,
  • it starts spending after a long silence, or
  • it was created moments ago and is already spending heavily.

A flagged key is held to a reduced per-key request rate for up to one hour. The hold is deliberately the smallest thing that limits the damage:

During a hold
The flagged keyrequests over the reduced rate answer HTTP 429; requests under it are served normally
Your other keysunaffected
Your balance, limits and settingsuntouched
The key itselfnot disabled and not revoked
Ending the holdautomatic; nothing to appeal or re-enable

A client that already retries on 429 with backoff needs no change. If one key returns sustained 429s while its siblings are fine, open Logs, filter by that key, and look at what it has been asked to do in the last hour.

The baseline is per key, so a batch job that spends a lot every night is that key's normal and is left alone.

Revoke a key for good

Disabling a key was always reversible, which is the wrong property for a key someone else holds. Revoking a key is a separate, terminal state.

The API Keys list filtered to Status: Revoked: one key, shown as Revoked, with its last use
  • Immediate. Requests with a revoked key are refused with 401 from the moment you confirm. The answer is the same one an unknown key gets, so it tells a stranger nothing.
  • Permanent. No path sets a revoked key back to enabled: not Enable, not Rotate, not an API call. Its history stays readable under Status: Revoked until you delete it.
  • Rotation without downtime. Rotate creates the replacement and lets you keep the old key working for a period you choose, or revoke it in the same step.

When Apertis learns that a key was exposed, for example from a report, we revoke it and email the owner. The message is titled "An Apertis API key on your account was revoked". It names the key by id, never by value, gives the UTC time, and links to API Keys for the replacement. For an organization key it also goes to the organization's owners.

Check a key's format offline

Keys issued since late October 2026 use a fixed shape: the prefix sk-apx_, 40 random base62 characters (about 238 bits), and a 6-character checksum of those 40.

KeyShape
Personalsk-apx_ + 46 characters
Subscription plansk-sub_apx_ + 46 characters
Organizationsk-org_apx_ + 46 characters

What that gives you:

  • Secret scanners match it exactly. sk-(sub_|org_)?apx_[0-9A-Za-z]{46} has no false positives from other vendors' sk- keys, and a scanner can verify the checksum before raising an alert.
  • Typos are caught before the network. The checksum is CRC32 of the 40 random characters, written as six base62 digits:
import zlib

ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

def looks_issued(key: str) -> bool:
    body = key.rsplit("apx_", 1)[-1]
    if len(body) != 46:
        return False
    n, check = zlib.crc32(body[:40].encode()), ""
    for _ in range(6):
        n, digit = divmod(n, 62)
        check = ALPHABET[digit] + check
    return check == body[40:]
  • A mistyped key costs no lookup. A key of this shape with a wrong checksum is refused before any cache or database read, with the same 401 as an unknown key.

Keys issued before the change keep working unchanged.

Set limits that bound a leak

Detection reacts after the fact. A limit on the key decides the worst case in advance, and each one answers with its own error so your client can tell them apart.

Limits & routing in the Edit key dialog: a US$500 credit limit, the monthly limit, a spend limit of US$5 per hour, allowed models and an IP allowlist of one range
SettingWhat it boundsWhen it is reached
Spend limit per hourspend in any trailing hour429 api_key_spend_rate_exceeded with Retry-After
Credit limitlifetime spend of the keythe key stops when the limit is used up
Monthly limitthe key's share of your account's monthly limitrefused until the monthly reset
IP allowlistwhere the key can be used from403, naming the allowed subnet
Expireshow long a forgotten key keeps workingrefused as expired
Permissionsall, restricted or read_onlyrefused outside its scope

When the hourly spend limit is reached, the error body looks like this:

{
  "error": {
    "message": "This API key has reached its spend limit of US$5.00 per hour. Retry after 1240 seconds, or raise the limit in the key's settings.",
    "type": "rate_limit_error",
    "code": "api_key_spend_rate_exceeded"
  }
}

The Key safety row above your key list counts the enabled keys that have no credit limit, never expire, or have been idle for 90 days or more. Each count is a filter: click it to see exactly those keys.

The Key safety row above five active keys: 3 with no credit limit, 3 never expire, 1 idle 90+ days

If a key leaks

  1. Revoke it in API Keys. Do not disable it: disabled can be undone by anyone with access to the account.
  2. Create the replacement with a spend limit per hour and, where the caller has a fixed address, an IP allowlist.
  3. Read what it did. Logs filtered by that key shows every request it made, with model, tokens and cost.
  4. Find the exposure: a public repository, a shared CI log, a client-side bundle.
Read update