Plans and tiers

An enterprise agreement with Graine raises the ceilings that actually constrain a production integration, and opens deployment shapes the shared cloud cannot offer. Concretely, it moves seven things: how many calls you can run at once, how you are deployed, where your data is processed, how long your audit trail is kept and exportable, what you pay per minute, how you are billed, and how you are supported.

Each of those is a stored per-organization value, not a code path — which is why a limit can be raised for your account alone, live, and take effect across every worker within a minute, with no release and no restart.

Commercial values — rates, minimum commitments, payment terms and support terms — are quoted per agreement and appear below as Contact sales.

What enterprise adds

How a plan is applied

There is no plan catalog inside the platform. The organization configuration document has no plan field — a plan name is a label carried on the API key, and the only behaviour attached to it is a privilege ladder: a key may mint a new key on its own plan or a lower one, never a higher one. What governs your account is the set of per-organization values in this page, each independently adjustable.

That is an advantage in a negotiation rather than a gap. The honest answer to "what does Enterprise include?" is "these dimensions, set to what you need," and any one of them can be changed for your organization alone without waiting for a release.

Read your own account's settings at any time:

curl -sS https://api.graine.ai/v2/user/me \
  -H "Authorization: Bearer gat_YOUR_API_KEY"

{
  "organization_id": "organization-live-example",
  "developer": {
    "id": "dev_example",
    "name": "Example Integration",
    "key_id": "key_0f3a9c2b71d45e68",
    "key_preview": "gat_...4e68"
  },
  "plan": "trial",
  "rate_limit_tier": "trial",
  "concurrency": {
    "max": 100,
    "current": 12,
    "agent_max": 100,
    "global_max": 1000,
    "enforced": true
  },
  "wallet": {
    "currency": "USD",
    "balance": 4.35,
    "allocated_total": 5.0,
    "lifetime_allocated": 5.0,
    "total_spent": 0.65
  },
  "rate_limits": {
    "default_per_minute": 1000,
    "calls_per_minute": 500,
    "executions_per_minute": 500
  }
}

That single response is the authoritative statement of your tier.

Concurrency

The most consequential dimension: how many calls your organization may have in flight simultaneously. It is enforced by an atomic governor before every dial, not reconciled afterwards, so the limit is a real ceiling rather than a reporting threshold.

Your effective limit is the lower of the organization and per-agent values, which is why /v2/user/me reports both. The per-agent level only gates when it sits below the organization limit; above it, the value is tracking-only.

The first three levels are atomic counters in Redis incremented by a single Lua check-and-increment, so two workers cannot both take the last slot. Limits are read from the organization configuration and cached for 60 seconds — which is what makes "raise us to 400 lines for tomorrow's campaign" a configuration change rather than a deployment.

Exhausting concurrency is not something you have to infer. The call request is refused with a specific code, and the response carries Retry-After:

{
  "error": 1300,
  "message": "Account concurrency limit reached (25 of 25 lines in use)."
}

When the live counts cannot be read the message degrades to Account concurrency limit reached; all lines are in use. — the code stays 1300 either way, which is what you branch on.

Audit retention and export

Every state-changing request on the /v2 API writes one row to an append-only, per-organization audit log, and every row is exportable through the API. The retention window is genuinely adjustable per organization.

400 days is the default so a full financial year plus a filing month is always available. Rows are removed after the window by a sweep that records what it pruned, so legitimate retention and tampering stay distinguishable — a pruned log still verifies clean.

Export is a normal API read, filterable by action, resource, acting API key and time window:

curl -sS "https://api.graine.ai/v2/audit-logs?action_prefix=api_key.&since=2026-08-01T00:00:00%2B05:30" \
  -H "Authorization: Bearer gat_YOUR_API_KEY"

Each row carries its own hash and the hash of its predecessor, so an exported log can be re-verified independently of us. A live verification endpoint returns the same result:

curl -sS https://api.graine.ai/v2/audit-logs/verify \
  -H "Authorization: Bearer gat_YOUR_API_KEY"

Reading the audit log requires a key holding the audit:read scope. The mechanism, including what verification actually detects, is described in Security.

Deployment model and data residency

Covered in full on Deployment. Its bearing on tiering:

The shared cloud runs in fixed regions:

There is no per-tenant region pinning on the shared cloud — region is a property of the deployment. Single-jurisdiction processing is therefore a dedicated or customer-hosted deployment, scoped before contract rather than toggled in a settings page.

Calling window and feature flags

Six flags are set per organization and govern whole subsystems.

Calling-window enforcement is usually a compliance requirement rather than a preference, so it is worth stating separately. Each organization carries a timezone, a weekly schedule (default 09:00–18:00, Monday to Friday), a holiday list, and per-category overrides — follow-up calls, for instance, ship exempt from the window by default. Retry behaviour is configured alongside it, per outcome category, with both fixed-delay and exponential-backoff strategies.

Rates, the wallet and the credit ledger

Usage is metered against a prepaid credit balance. Every rate is stored per organization and is overridable per organization — that is the mechanism behind any negotiated commercial rate.

Rates live in organization_configs.cost_management, in USD, in two layers:

• A flat default per cost component, used when nothing more specific applies: telephony, transcription, synthesis, language model, and a platform fee.
• Per-provider and per-model rates, in the natural unit for each: telephony and transcription per minute, speech synthesis per 1,000 characters, language models per 1,000 tokens.

Your effective rates are readable rather than inferred:

curl -sS https://api.graine.ai/api/v1/credits/rates \
  -H "Authorization: Bearer gat_YOUR_API_KEY"

The credit ledger

Worth understanding because it is what your finance team will audit. Every movement of money is written as a ledger entry first and a balance second. Entries are typed — seed, top-up, grant, refund, correction, charge reversal, charge re-application — and reversing a charge is deliberately not the same operation as granting credit, so the two never blur in a reconciliation.

Entries carry an idempotency key with a uniqueness constraint, and the entry is inserted before any balance moves. A retried or double-submitted payment therefore loses the insert and returns the original entry rather than paying out twice. The remaining balance is always derived from allocated minus spent rather than read from a stored mirror, and adjustments above a fixed ceiling are refused outright rather than silently applied.

Every debit is auditable:

curl -sS "https://api.graine.ai/api/v1/credits/ledger" \
  -H "Authorization: Bearer gat_YOUR_API_KEY"

A call is refused before it dials if the wallet cannot fund it:

{ "error": 1400, "message": "Insufficient credits to place this call." }

Support

The platform stores a support tier per organization with an integer priority; standard and premium are seeded on organization creation. What a tier entitles you to — channels, response targets, escalation path and whether you have a named technical contact — is a contract term rather than a platform behaviour.

Response-time and availability commitments are agreed in the contract. Graine does not publish them as marketing figures.

API rate limits

Applied per organization on the /v2 API as a weighted sliding window, executed as a single atomic operation so two concurrent requests cannot both see headroom.

Limits are keyed per organization, not per key, so minting more keys does not multiply your quota. Every response carries X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset; a rejected request adds Retry-After and returns:

{
  "error": 1300,
  "message": "Rate limit exceeded: 1000 requests per minute for this organization. Retry in 12s."
}

These limits read a platform value rather than a per-organization one, so they are the same for every organization today and a higher request limit is a platform change rather than an account setting. Raise it during scoping if your integration needs it. In practice, spend and calling capacity are bounded by concurrency and the funding gate rather than by request rate; the limiter is a fairness control.

Reconciling usage

Usage aggregates are available directly, for the period and grouping you choose.

curl -sS "https://api.graine.ai/v2/usage?from_date=2026-08-01T00:00:00%2B05:30&to_date=2026-08-26T00:00:00%2B05:30&group_by=day" \
  -H "Authorization: Bearer gat_YOUR_API_KEY"

The response reports call counts, connected minutes and spend. Results are cached for 60 seconds per organization and filter set.

Usage aggregates are computed from call records rather than from the credit ledger, so they answer "what did we do" quickly. For "what were we charged", reconcile against the ledger, which is the authoritative financial record.

Scoped before contract

A few things are agreed in a scoping conversation rather than switched on in a settings page. Stated here so they do not surface late in a procurement cycle:

• Invoicing, purchase orders and tax documents are handled outside the platform.
• Billing is in USD. Internal accounting uses a single currency.
• Encryption keys at rest are platform-held. Field-level encryption covers phone numbers, webhook signing secrets and customer authentication headers — see Security.
• Region is a property of the deployment, not a per-tenant setting on the shared cloud.
• Committed-spend and annual terms are contractual and reconciled outside the platform.