Storage
One hot/cold pipeline for every stored content type. AES-256-GCM at rest, per-project keys, tier-driven TTL on the hot path, forever-while-funded retention on the cold path except stored responses (90 days), one billable pool.
All storage types share a unified billing pool per project. There is no separate metering for each content type; your total storage usage across all types determines your billable amount.
Tier Windows
The hot window is an in-memory cache TTL, set per service tier as its completion hot-cache retention. The cold window is no longer tiered: durable object storage is retained for as long as the project is funded. There is no per-tier cold expiration. One type differs: a stored Responses API response is deleted, with its stored input and output, 90 days after it is created. Every section below references this matrix rather than restating it.
| Window | Duration |
|---|---|
| Hot (Cache) | Set by the endpoint's service tier |
| Cold (Object) | Forever while funded; stored responses 90 days |
When a project's credit balance reaches zero, or a storage charge is larger than the balance left, a 96-hour grace window starts. Cold content is purged only after that grace window elapses while the balance stays at or below zero; topping the balance back up clears the grace clock and keeps the content. Special-mode projects are exempt from purge.
Storage Types
The following content types are stored by the platform:
| Type | Description | What Is Stored |
|---|---|---|
| Models | Uploaded model weights | GGUF/safetensors files |
| Completions | Chat completion results | Request/response pairs |
| Responses | Responses API results, kept 90 days after creation | Input/output content |
| Conversations | Conversation items | Message content |
| Batch Files | Batch API input/output | JSONL files |
| Uploads | Multi-part uploads | Assembled files, and the chunks of uploads still in progress |
| Chat | Chats in the web, desktop and iOS apps | Messages, attachments, generated audio and images, memories, document chunks, branches and share links |
| Workspaces | Workspace data | Workspaces, milestones, decisions and their relations |
| Exports | Data exports not yet expired | Export files |
| Execution records | EEM tool calls | The execution audit trail and execution memories |
| Audit log | Admin and security actions | Audit log entries |
Hot Tier (Cache)
In-memory layer for recently created or recently accessed content. Reads are typically sub-millisecond. Items are written here on creation and re-populated automatically on cold tier hits.
- TTL
- Per service tier, see Tier Windows.
- Behavior
- Auto-populated on write, evicted after TTL.
- Availability
- Best-effort; cache misses fall through to cold.
- Encryption
- Same AES-256-GCM payload as cold.
Cold Tier (Object Storage)
Durable layer. All content is written here on creation (dual-write with the hot tier) and persists for as long as the project is funded. Each project's objects live in their own container with per-project encryption keys.
- Retention
- Forever while funded; purged 96 hours after the credit balance reaches zero. A stored response is deleted 90 days after it is created. See Tier Windows.
- Encryption
- AES-256-GCM at rest.
- Isolation
- Per-project containers, per-project keys. Shared object-store infrastructure, isolated at the container and key-prefix level.
Retrieval
When stored content is requested, the system uses an automatic waterfall retrieval strategy. This is transparent to API consumers, the same endpoint serves content regardless of which tier it resides in.
- Hot tier check, The in-memory cache is checked first for sub-millisecond access.
- Cold tier fallback, If the item is not in the hot tier (e.g., TTL expired), it is loaded from cold storage and decrypted.
- Cache re-population, On a cold tier hit, the item is automatically promoted back to the hot tier so subsequent reads are fast.
Note: If content is gone from both tiers (purged from cold after the post-depletion grace window and evicted from cache), requests return a 404. Database rows for stored items persist by default, though some cleanup paths (notably Files and Uploads) may soft-delete the metadata row; see each type's documentation for specifics.
Encryption
All stored content is encrypted at rest using AES-256-GCM in both tiers. Encryption and decryption are handled transparently, content is encrypted before writing to either tier and decrypted automatically on retrieval.
- Algorithm
- AES-256-GCM.
- Scope
- Per-project encryption keys.
- Integrity
- Checksum verification on every read.
- Key rotation
- Supported with zero downtime. Existing ciphertext decrypts against retained prior key versions.
Storage Billing
All storage types contribute to a single billable total per project. There is no per-type billing; combined usage across every storage type determines the bill.
| Property | Details |
|---|---|
| Pool | Shared, all storage types contribute to a single billable total per project |
| Minimum charge (display) | 1 GB minimum is applied to the Usage dashboard rollup as soon as any storage is used |
| Formula (display) | Displayed billable GB = actual total usage rounded up to the next whole GB when usage > 0, minimum 1 GB; 0 when nothing stored. The underlying time-weighted credit deduction is computed from actual bytes, the rounding is a dashboard rule, not a ledger floor. |
| Rate | Platform-wide per-GB monthly rate, the same on every service tier (visible on the Usage dashboard, and on Pricing) |
| From the first byte | No tier includes free storage. Storage is charged from the first byte, on every tier, including Free |
| GB | 1,073,741,824 bytes (10243), the same GB the quota is measured in |
| What is measured | The size of what you store: file and model sizes, and the bytes of each stored record. Database indexes and filesystem overhead are not counted |
| Charge (ledger) | Time-weighted on actual bytes between measurements, at the per-GB monthly rate over a 730-hour month. No minimum charge |
| Cost | billable_gb * rate_per_gb |
| Monitoring | Storage breakdown by type visible on the Usage dashboard |
| Quota | 50 GB per project by default, covering everything the project stores: models, files, batch data, chat and workspace uploads, and the rest of the types above. The usage figure in project settings is the figure the allowance counts, and the platform tells you when you reach it. To request more storage, contact support. |
Retention & Lifecycle
| Layer | Duration | Eviction | Notes |
|---|---|---|---|
| Hot (Cache) | See Tier Windows | Auto-eviction after TTL | Non-blocking, best-effort |
| Cold (Object) | See Tier Windows | Purged 96h after balance hits zero; a stored response 90 days after creation | Encrypted at rest; kept while funded |
| Database Records | Indefinite | Manual deletion only | Metadata persists after storage expiration. Some cleanup paths (see Files, Uploads) may soft-delete the row. |
Per-Type Limits
| Type | Max Item Size | Other Limits |
|---|---|---|
| Models | The service tier's max model size, checked when an endpoint is created; Pricing lists each tier's value | Delivered via the Uploads API; see Service Tiers |
| Completions | Varies by model context | - |
| Responses | Varies by model context | - |
| Conversations | 1 MB per item | 20 items per request, 16 metadata keys |
| Batch Files | 500 MB per file | - |
| Uploads | 200 MB per chunk (multi-part) | Single-shot file endpoints capped at 200 MB body; multi-part uploads have no total-size limit beyond the project storage allowance |
Each project has a 50 GB storage allowance by default. It covers all stored data: models, files, batch inputs and outputs, chat and workspace uploads, stored responses and the rest of the types on this page. A model counts while its files are stored, including one that failed validation.
When the project's stored data reaches its allowance, the project's owners get an email and the dashboard shows a notice: delete stored data you no longer need, or contact support to request more storage. The notice is sent once, and again only after usage has dropped below 95 percent of the allowance.
When the project's storage is full, a write you send that
adds stored data is refused with 400 and code
storage_quota_exceeded: model uploads at
initialization and again at completion, file uploads,
batch creation (sized by its input file), conversation
items, memories created through the memory endpoints or
the dashboard, and chat and workspace uploads. Data the
platform writes as part of work already admitted, such as
batch output files, stored responses and exports, is not
refused mid-run; it counts toward the total. If that data
leaves the project out of storage, inference stops: chat
completions, responses, embeddings, rerank, score, System
One, audio, realtime and batch creation are refused with
402 and code storage_exhausted,
and the owners get an email and a dashboard notice. Reads
and deletes keep working. Inference resumes on its own once
the project deletes enough stored data or its allowance is
raised.
See the documentation for each API for the full set of constraints: Stored Completions, Responses API, Conversations, Batch API, Files API, Uploads API.
Checking Usage
Storage usage is visible on the Usage dashboard: per-type breakdown (GB), combined total, billable amount (actual usage rounded up to the next whole GB, minimum 1 GB), and estimated monthly cost at the platform per-GB rate. See Usage Tracking & Billing for the broader billing system.
Endpoint-level request counts and token usage are exposed via the usage API below. Per-type storage byte counts are dashboard-only.
// tip Press Alt+e to cycle focus through the examples.
Replace {project_id} with your project's external id
(e.g. proj_abc123) and set EREBINE_API_KEY
to a valid project API key before running these examples.
# Retrieve per-endpoint request counts and token usage
curl "https://api.erebine.ai/{project_id}/v1/usage/endpoints" \
-H "Authorization: Bearer $EREBINE_API_KEY"
import os
import requests
project_id = "{project_id}"
headers = {"Authorization": f"Bearer {os.environ['EREBINE_API_KEY']}"}
response = requests.get(
f"https://api.erebine.ai/{project_id}/v1/usage/endpoints",
headers=headers,
)
response.raise_for_status()
payload = response.json()
for endpoint in payload["data"]:
print(
f"{endpoint['endpoint_slug']}: "
f"{endpoint['request_count']} requests, "
f"{endpoint['total_input_tokens']} input tokens"
)
const projectId = "{project_id}";
const response = await fetch(
`https://erebine.ai/${projectId}/v1/usage/endpoints`,
{
headers: { "Authorization": `Bearer ${process.env.EREBINE_API_KEY}` }
}
);
if (!response.ok) {
throw new Error(`Usage request failed: ${response.status}`);
}
const payload = await response.json();
payload.data.forEach(ep => {
console.log(`${ep.endpoint_slug}: ${ep.request_count} requests`);
});