# What everything costs, and the limits that keep it safe

Every feature is available on every account. Pricing is usage-based: a free monthly allowance, then metered rates for anything past it, drawn from a prepaid balance. Top-ups start at $5 and balances do not expire. Paid work stops when funds are unavailable unless optional auto-recharge adds funds.

## Rates

1,000,000 included events / month free 10 shared AI units / month included 90 day raw event retention

There are two units of account, events and AI units. Events are counted on one event meter: a player event or text report is 1 event, a screenshot report adds 20,000 and an MCP call is 100,000, and what Pulse and connections store is weighted by row, as below. One studio shares the monthly allowance across every project and every environment in it. Browsing saved dashboard data uses neither.

| What | Price | Included allowance? |
| --- | --- | --- |
| Events on the meter past the allowance | $0.05 per started block of 100,000 | 1,000,000 a month |
| An AI unit past the allowance | $0.20 | 10 a month |
| Analyst question, Design chat turn, risk check, investigation analysis, digest, brainstorm question, strategy matrix suggestion, market research run, market research quick look, market draft | 1 AI unit each | Yes |
| Feedback enrichment | 1 AI unit per batch of up to 25 items | Yes |
| Pattern synthesis, the deep tier | 5 AI units ($1.00) | No, prepaid balance only |
| Deep market research | 25 AI units ($5.00) | No, prepaid balance only |
| Player Report | 1 event for the text, plus 20,000 events for a screenshot | Yes, as events |
| Pulse: each post, snapshot, comment and reaction stored | Post 1,000 events; snapshot 100; comment, reply or quote 300; reaction or repost 20; each read of a connected source 50. A row already stored costs nothing | Yes, as events |
| Pulse: Huginn's summary of a post's comments, or of a date range | 1 AI unit; asking again with no new comments is free | Yes |
| Pulse: reading a watched link | 1,000 events plus 1 event per byte read, at most 2 MB a read (about 2.1 million events) | Yes, as events |
| Connection sync | 500 events plus 1 event per byte read; each new sales row or snapshot 100, each new post 1,000 | Yes, as events |
| MCP call, read or write | 100,000 events ($0.05 past the allowance) | Yes, as events; needs an account that has funded a balance at least once |
| Exported event (bucket export) | 5 events per event exported (100,000 exported events are $0.25 past the allowance) | Yes, as events |
| Source scan, first scan | $5 under 250 KB, $10 under 1 MB, $25 under 4 MB, $50 under 16 MB | No, prepaid balance only |
| Source scan, rescan | $2 while the changed source is under 250 KB, otherwise its size tier; free when nothing changed | No, prepaid balance only |
| Playtest | $6.40 a persona run, $8.20 a long persona run, $8.40 a game profile, $18.60 a fix attempt. A persona run that ends short of 15 actions through no fault of the game, or that did not earn its price but used AI time, is billed at what it cost us | No, prepaid balance only |
| Cloud playtest, each persona | $3.60 Jam (5 minutes), $4.80 Small (8 minutes), $8.00 Medium (15 minutes), $15.80 Large (30 minutes, including a $1.00 non-refundable setup fee); a longer play length is priced by the quote, for example $28.80 for 60 minutes on Medium. A build too large for its tier keeps the time and model spend used plus a $2.00 fee | No, prepaid balance only. [Cloud playtests](https://ravensight.io/docs/playtest/#playtest-cloud) |
| Hosted Linux simulation | $6.09 a run, quoted as one total; the first run credits its $0.49 build deposit once | No, prepaid only; $10 initial verified funding, then enough available funds to cover each request. [Funding and refunds](https://ravensight.io/docs/playtest/#hosted-simulation) |

Each MCP call, read or write, is metered as 100,000 weighted events on the account-wide event meter, the same meter every game's player events draw from. At 100,000 events a call, the included 1,000,000 events cover about ten MCP calls in a month when nothing else is sent, and once MCP calls have used the allowance, every game's player events are billed from the first one. The usage page in **Settings > Billing** shows MCP calls as their own bar and line, and the sidebar meter gives them their own row, with the weighted events they were metered as and what that comes to at the event rate, beside the player events and text reports your games actually sent.

An agent can read the same thing without the dashboard: every metered MCP answer carries `_meta.remaining`, and `get_usage_rate` returns `allowance` and `balanceCents` (see [MCP](https://ravensight.io/docs/mcp/)). In a rate, `includedAllowance` refers to AI units only: MCP calls draw the included monthly events first, then the prepaid balance.

Source scans are quoted before they run. Playtest units are charged when a job registers and refunded for any unit that did not produce a usable result, including a persona run that ended early with no findings, and a fix attempt is refunded in full when it changed nothing, the finding was design intent, or the game did not boot for its verify run (up to twice in any 30 days per account, with CLI 0.6.0 or later). Once the model has been used, an account gets 5 refunds of a fix attempt, 5 of a game profile and 20 of a persona run in any 30 days. Past that the unit is kept and the job says so; work that used no model time always comes back. Failed, undelivered AI work is refunded.

## Rate limits

Per game, per 60 second window: 60 session creations and 600 tracked events. A batch call costs one unit per event, capped at the 50-event batch ceiling, so a full batch never charges more than a valid batch could. Both the versioned and legacy ingestion paths share the same budget for a given game. A [public key](https://ravensight.io/docs/public-builds/) adds its own limits per key, per session and per device id below these. `GET /api/v1/settings` allows 30 reads a minute per key and connecting address.

Every rate limit is counted on the API server that answers the request, not in a shared store. Ravensight runs one API server today, so these figures are the limits your game sees. If more servers are added, a limit applies on each server separately until this page says otherwise.

## Payload ceilings

Request bodies are capped at 100KB, except `/track` and `/track/batch`, which take 512KB so a full batch of error events with their stacks fits. Those two accept a body sent with `Content-Encoding: gzip` or `deflate`; the 512KB is counted after it is decoded, and any other encoding answers `415 unsupported_encoding`. Within them, an event name is capped at 200 characters and one event's data at 8KB serialized (a typed `error` event's `rs_message`, `rs_stack` and `rs_trail` count one byte a character there, so a stack of up to 2,000 characters always fits): events are gameplay facts, not documents. A batch containing one oversized event, or a batch past the request cap, answers 400, and every SDK halves the batch until it fits, isolating and dropping an offending event automatically, so a single bloated event never costs the rest of its batch. Feedback messages are capped at 2,000 characters.

## Data retention

Raw events are kept for 90 days by default; an owner can choose 180 or 400 days with [extended retention](https://ravensight.io/docs/extended-retention/). Before events age out, Ravensight extracts daily and monthly aggregates (active players, new players, sessions, events, top events, level funnels, cohort retention) and keeps those forever, along with lifetime totals per game. The 1y and All views in the dashboard, and the analyst's long-range answers, are served from these aggregates, even with extended raw storage. Guarded SQL via run_sql and the warehouse endpoint can read raw rows still retained for the game, subject to their execution limits. History collection can be switched off per environment in **Settings > Projects**; production, early access and demo environments keep it on by default, because the public plays them; alpha, beta, staging, development and custom environments start with it off.

One consequence worth knowing: the aggregates are computed from real player sessions only, and carry no column saying which rows an AI persona produced. So the long-range history endpoints take no persona scope at all, because there is nothing there to include. Your 1y and All numbers are real players, always. The **Real players** select applies to raw-event views; it does not add synthetic traffic to historical rollups.

Raw event export

```
GET /api/v1/games/<gameId>/analytics/events/export?after=0&skip=0&limit=10000
Cookie: gt_session (dashboard sign-in)

{ "events": [ { "deviceId", "sessionId", "event", "ts", "level",
               "platform", "gameVersion", "data",
               "schema", "gameId", "tsIso", "synthetic", "props",
               "rs" }, ... ],
  "nextAfter": 1755648000123, "nextSkip": 3 }
```

Oldest first, up to 10,000 events per page; keep requesting with `after = nextAfter` and `skip = nextSkip` until `nextAfter` is null. Events can share a timestamp, and `skip` is how many events at that timestamp you already have, so no page boundary drops or repeats one. Export anything you want to keep beyond the game's selected raw-event retention window.

The first eight keys are unchanged. Each event also carries `schema` (the row format version, currently 1), `gameId`, `tsIso` (the timestamp as UTC ISO text), `synthetic` (true for a playtest session, which the export leaves out unless you ask), `props` (the event's top-level properties as text) and `rs`. The `rs` object is the typed event contract read back: `kind` is the `rs_kind` you sent (or null), and a purchase, resource, progression, error or health event adds a `purchase`, `resource`, `progression`, `error` or `health` object with its fields. A purchase `amount` is a string of whole minor units, and resource amounts, scores and health metrics are decimal text, exactly as stored. An event that broke the contract carries `rs.invalid` with the reason and no field object. Events also carry `country`, `deviceModel`, `osVersion` and `gpu` from the session, and `campaign`, `adset` and `creative` from the device's acquisition record; each is null when unknown. Keys are only ever added to this shape, so read the ones you know and ignore the rest.

## Safety ceiling

There is a safety ceiling of 500,000,000 events a month per account, which applies even with a balance loaded. It exists so a runaway loop or a broken build cannot turn a prepaid balance into hundreds of millions of events you never meant to send, and it is checked before anything is charged, so a refused batch costs nothing. Past it you get the same `429 quota_exceeded`, with a message saying it is the ceiling rather than the allowance. If that volume is genuinely yours, ask and we will raise it.

AI actions use Ravensight-managed providers and the shared prepaid balance. Customers do not supply provider API keys.

Source: https://ravensight.io/docs/limits/
Last updated: 2026-11-15
