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

# Changelog: November 2026

> What changed in Mesh in November 2026.

**November 2026**

User provisioning from Okta (SCIM); choose whether removing a member suspends their keys; your request logs in your own Grafana; video routes per input type and a dedicated edits endpoint; web search follows the key's tool policy; `weight_profile` on router select; long-context 1-hour cache writes priced on their own; WebSocket keys out of the URL; top-level speech `speed`; MiniMax `vol` and `emotion`; 12-hour prompt-cache writes priced on their own; agent run tracing with `X-Mesh-Run-Id`; a key can describe its own org, scopes, model access and limits

## User provisioning from Okta

**Added.** Okta can now add and remove the members of your Mesh organization over
SCIM 2.0. In **Settings → Single sign-on**, click **Set up provisioning** under
**User provisioning (SCIM)**, then paste the base URL and token into Okta. Assign someone
in Okta and they join as a Member; unassign them and they leave, with their API keys
suspended. Push an Okta group, pick it under **Group roles** on the same card, and set it
to **Admin** to make its members admins.
Someone who already has a Mesh account is linked, not duplicated. The owner is never
removed, and removing someone in Mesh sticks. Enterprise, alongside SSO. See
[User Provisioning](https://developers.meshapi.ai/docs/getting-started/user-provisioning.md).

## Choose whether removing a member suspends their keys

**Added.** In **Settings → People**, click **Remove** on a member: the dialog now lists
the API keys they created and suspends them by default. Untick **Suspend these keys** to
keep them working under your organization's limits. Set the default with the
**Removing a member → Suspend their API keys** switch on the same page. Admin keys can do
the same through the [Admin API](https://developers.meshapi.ai/docs/reference/admin-api.md#members-and-invitations). See
[Removing members](https://developers.meshapi.ai/docs/getting-started/organizations.md#removing-members).

## A key can describe itself

**Added.** `GET /v1/keys/{id}` reports what an API key **is and may do** — its org,
status, scopes, model access and resolved limits — and never returns the key secret or
its hash. Unlike the other key-management routes, an `rsk_` key may call it **for
itself**: the `{id}` must be the key's own id, and any other value is `404`, so it is no
way to probe for other keys. A [`mak_` admin key](https://developers.meshapi.ai/docs/getting-started/admin-keys)
holding `keys:read` can describe any key in its reach. A suspended key, or one blocked by
its IP allow-list, cannot reach it. See [API Keys](https://developers.meshapi.ai/docs/getting-started/api-keys.md#inspecting-a-key).

## Your request logs in your own Grafana

**Added.** Mesh serves a Loki-compatible read API over your organization's request logs.
In Grafana, add a **Loki** data source with the URL `https://api.meshapi.ai/v1/logs` and an
`Authorization: Bearer mak_...` header, then query the logs in Explore and Logs Drilldown.
The key must be an [admin key](https://developers.meshapi.ai/docs/getting-started/admin-keys.md) holding `logs:read` at
`org` scope; an `rsk_` key gets `401`. Every query reads only the calling key's
organization.

Each authenticated HTTP request has one `http_request` record, kept 7 days, with
OpenTelemetry field names: `http_request_method`, `http_route`, `url_path`,
`http_response_status_code`, `client_address`, `user_agent_original`, `request_id`,
`key_id`, `org_id`, `owner`, and `trace_id` / `span_id`. `latency_ms` is the time to the
response headers (time to first byte on a stream) and `total_duration_ms` the time until
the body finished. An unusual method is recorded as `_OTHER`, with the raw value in
`http_request_method_original`. The labels are `service_name` and
`deployment_environment_name`. Request and response bodies are not in these records, and
your own calls to `/v1/logs` are not recorded.

The API serves the read paths Grafana uses under `/v1/logs/loki/api/v1/`: `query`,
`query_range`, `labels`, `label/{name}/values`, `series`, `detected_labels`,
`detected_fields`, `detected_field/{name}/values`, `patterns`, `format_query`,
`index/stats`, `index/volume`, `index/volume_range` and `status/buildinfo`. Live tail,
push, OTLP, delete and rules paths return `404`.

* **600 requests a minute per organization**, across all your keys and dashboards. Past
  it the answer is `429` with `Retry-After`.
* **32 MiB per answer.** A larger one is refused with `422` `log_result_too_large`, never
  cut short; narrow the time range or the query.
* **Nothing before 2026-11-12 11:00 UTC.** A time range that starts earlier is moved
  forward. An instant query that reaches before that time, a query using `offset`, or a
  time or query parameter given twice returns `400`.

**Added.** `GET /v1/logs/bodies` returns the request and response bodies your body-log
policy exports, newest first. Filter with `request_id`, `key_id`, `since` and `until` (at
most 7 days apart; the last hour by default) and `limit` (1 to 50, default 20); it takes
these typed filters, not LogQL. Page with the returned `next_cursor`, sending the same
window and filters each time. A page can hold fewer records than `limit`, or none, while
`next_cursor` is still set; the last page has no `next_cursor`.

* Every read is written to your audit log as `log_bodies.read` before anything is
  fetched; if the audit store is down the answer is `503`.
* With zero data retention on, the answer is `403`, even for bodies stored before it was
  turned on. If the setting cannot be confirmed, `503` `zdr_state_unavailable`.
* The body-log policy is read again on every read: turn a key's policy off, or narrow it
  to one direction, and its bodies stop being served, including ones already stored.

**Added.** Two org permissions. `logs:read` covers the Loki paths and is held by the
owner, admin and viewer roles. `logs:read_bodies` covers `GET /v1/logs/bodies`, is held
by owners and admins only, cannot be carried by a custom role, and is never implied by
`logs:read`. Both can be granted on an admin key.

## Video: a route per input type, and a dedicated edits endpoint

**Added.** `POST /v1/video/t2v`, `POST /v1/video/i2v` and `POST /v1/video/v2v` take the
same body as `POST /v1/video/generations`; the path names the modality the serving model
must support. A model without it, or any fallback target without it, returns `422`
before any provider call. Jobs stay asynchronous: submit, then poll the task.
`GET /v1/models` and `GET /v1/models/{id}/providers` now return `supports_t2v`,
`supports_i2v`, `supports_v2v` and `video_options` on each model and provider, so you
can pick a model for a route before you submit.

**Added.** `POST /v1/video/edits` takes video edits.

**Changed (API version `2026-11-12`).** On requests pinned to `2026-11-12`,
`POST /v1/video/generations` takes a text prompt and reference images (`image_url` items
with `role: "reference_image"`); frames, video, audio, `previous_task_id` and other edit
inputs go to `POST /v1/video/edits` instead and are a `422` on generations. A
resolution, ratio or duration the model does not support is refused. Requests on
earlier versions, including unpinned keys, keep the combined body. See
[API versioning](https://developers.meshapi.ai/docs/reference/api-versioning.md).

## Web search follows the key's tool policy

**Changed.** `POST /v1/web/search` now checks the key's `tool_policy`, as a model
request's tools already did. A key whose policy blocks `web_search`, or whose `allowed`
list does not name it, gets `403` `tool_not_allowed` with `details.tool: "web_search"`.
A video submit with `web_search: true` is refused the same way. Keys with no tool policy
are unaffected; to keep access on a key with an `allowed` list, add `web_search` to it.

## `weight_profile` on `/v1/router/select`

**Added.** `POST /v1/router/select` accepts `weight_profile` in the body (or the
`X-Mesh-Weight-Profile` header; the body wins) and resolves the profile the same way
`POST /v1/chat/completions` does: the request, then the key, then its team or
organization template, then the default. It used to use the global default every time.
An unrecognised name falls back to `balanced` instead of failing the request. See
[Routing Algorithms](https://developers.meshapi.ai/docs/capabilities/routing-algorithms.md#choosing-a-profile) for the
precedence, and [Auto-routing](https://developers.meshapi.ai/docs/capabilities/auto-routing.md#steering-the-choice) for
which requests a profile can affect.

## Long-context 1-hour cache writes are priced on their own

**Added.** `GET /v1/models` returns `long_context_cache_write_1h_input_usd_per_1m` in each
model's pricing: the price per 1M tokens of a 1-hour cache write on a prompt over the
model's long-context threshold. It is `null` on models without a separate rate.

**Changed.** Those writes now bill at that rate where a model has one (today, models
served directly by Anthropic) instead of the long-context 5-minute rate. Models where
the field is `null` bill as before.

Releases v1.0.377 to v1.0.412.

## WebSocket keys out of the URL

**Fixed.** The realtime, live and audio WebSockets take your key as the subprotocol
`openai-insecure-api-key.<rsk_...>` (the form OpenAI's browser client sends) or as an
`Authorization: Bearer rsk_...` header. The `Bearer rsk_...` subprotocol these docs
showed before never connected: a subprotocol can't contain a space, so the handshake
failed with a `400`. `?api_key=` keeps working unchanged, though a URL ends up in logs, so
prefer the two forms above. If a request carries more than one, the subprotocol wins, then
the header, then `?api_key=`. See
[Realtime audio authentication](https://developers.meshapi.ai/docs/capabilities/realtime-audio.md#authentication).

**Changed.** Mesh echoes back the first subprotocol you offer that is not the key, and
none when you offer none. `/v1/realtime` and `/v1/live` used to answer `openai-realtime`
every time, which a client that offered `realtime` (OpenAI's browser client) or nothing
rejected.

## Speech speed control

**Added.** You can set a top-level `speed` (0.25 to 4.0) on `POST /v1/audio/speech`; it
used to be dropped without an error. Mesh forwards `speed` as sent and never clamps it, so
each provider applies its own range; a value outside 0.25 to 4.0 is a `422`. It takes effect on models served by DeepInfra,
SiliconFlow, Venice, and MiniMax on Novita; other models accept the value and ignore it.
`voice_settings.speed` still works unchanged and is the field ElevenLabs reads.

```json theme={null}
{
  "model": "<tts-model-id-from-GET-/v1/models>",
  "input": "Hello from Mesh.",
  "voice": "alloy",
  "speed": 1.25
}
```

## MiniMax speech: volume and emotion

**Added.** `POST /v1/audio/speech` accepts an optional `vol` field (greater than 0, up to
10\) and an optional `emotion` field on MiniMax speech models; other speech providers
ignore `emotion`. MiniMax speech requests now pass `pitch`, `vol` and `emotion` through to
the provider instead of dropping them.

**Changed.** A MiniMax speech request returns a `422` before reaching the provider, with
nothing billed, when `pitch` is not a whole number from -12 to 12, or when `emotion` is
`fluent` or `whisper` on a model other than speech-2.6.

## 12-hour prompt-cache writes are priced on their own

**Added.** `usage.prompt_tokens_details.cache_write_12h_tokens` reports the prompt tokens
written to the 12-hour prompt cache. `GET /v1/models` returns
`cache_write_12h_input_usd_per_1m` and `long_context_cache_write_12h_input_usd_per_1m`,
and their flex counterparts `flex_cache_write_12h_input_usd_per_1m` and
`flex_long_context_cache_write_12h_input_usd_per_1m`, in each model's pricing object.

**Changed.** 12-hour cache writes now bill at their own rate on standard, long-context and
flex pricing instead of the 30-minute write rate. Long-context pricing on the affected
OpenAI models now applies above 272,000 input tokens, matching OpenAI's published boundary.

Release v1.0.384.

## Trace an agent run

**Added.** Send the same `X-Mesh-Run-Id` header on every request an agent run makes, and
`GET /v1/usage/runs/{run_id}` reports the run as one unit: every hop oldest first, retried
attempts included and flagged, and one `total_charged_usd` for the whole run. It is a
header, so setting it once on your client's default headers carries it across every
request in the run.

**Added.** `run_id` is reported on each usage event and is a filter on
`POST /v1/usage/events` and `POST /v1/usage/rejections`.

An unusable run id — longer than 128 characters, containing `/`, or shaped like an API
key — is dropped, and the request is served exactly as if no header had been sent. No
request is ever refused over a run id. The accepted id is echoed back on the response as
`X-Mesh-Run-Id`, so read that header to confirm what was recorded.

[Run Tracing](https://developers.meshapi.ai/docs/reference/run-tracing.md) is the full reference.

## API

* You can now set `layer_decomposition` on an image generation request to split an input image into a base image plus up to 99 PNG layers.
* You can now control decomposition with `layer_decomposition_options`, which accepts `max_images` and `text_recognition`.
* `ImageOptions` now accepts the same `layer_decomposition` and `layer_decomposition_options` fields.
* Each item in `data[]` now includes provider-reported metadata when available: `size`, `output_format`, `background`, `z_index`, `bounding_box`, `name`, `description` and `text_recognition`.
* Layer decomposition works only on models that support it, and a decomposition request sent to any other model returns a `400`.
* An explicit `layer_decomposition: false` is accepted on any model and has no effect.
* The balance hold for a decomposition request is sized from `layer_decomposition_options.max_images`, so set it to avoid reserving balance for up to 100 images.
* Every returned image, including each layer, is billed at the tier of the requested size.

## API

* You can now read a key's details with `GET /v1/keys/{key_id}`, including its org, `scopes`, `allowed_models`, `blocked_models`, `model_limits` and effective limits.
* The response never includes the key's secret or hash.
* An `rsk_` key can read only itself, and any other `key_id` returns `404`.
* A `mak_` admin key or a user session with the `keys:read` permission can read any key within its scope, and a key outside that scope returns `403`.
* Effective limits use the same minimum-wins calculation as `GET /v1/keys/{key_id}/limits`.

```bash theme={null}
curl https://api.meshapi.ai/v1/keys/KEY_ID \
  -H "Authorization: Bearer rsk_YOUR_KEY"
```


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