Service Tiers
Six tiers on one price ladder, chosen per endpoint at creation. A tier sets the price, the limits and the scheduling priority. It carries no hardware: any tier can run on any mix of silicon. The request-level service_tier parameter only picks a processing lane -- priority and token multiplier -- within the tier you already picked.
A tier is a pricing plane. It sets three things:
- Price, The per-1M-token rate and the cached-token multiplier, plus an hourly rate per EIM on Self-Hosted.
- Limits, Endpoints per project, endpoints per task mode, uploaded models, max model size, the workspace storage cap, the request timeout, the stream idle timeout, and how long a stored completion stays in the hot cache.
- Scheduling priority, Where the tier's requests stand when Erebine Inference Microservices (EIMs) are contended.
A tier does not set hardware. Any tier can hold any mix of NVIDIA, AMD, Intel, Apple and CPU EIMs, and one endpoint can be served by that mix. Hardware needs come from the workload and are checked against each EIM's reported capability when the EIM is bound and when the endpoint is placed on it. See Hardware Requirements.
A tier does not set rate limits either. Rate limits are platform-wide, with per-project overrides; see Rate Limits.
Tier slugs (identifiers used in the API and configuration) are:
free, bulk, base,
plus, max, self_hosted.
This page describes the ladder and lists each tier's limits.
Pricing shows each tier's rate, read from
the live catalog.
Figures are behind sign-in. Per-token, cached, and hourly rates on Pricing are shown to signed-in accounts. Everything on this page -- what each tier bills for, the limits it sets, and how the ladder is ordered -- is the same either way. For a quote without an account, mail contact@erebine.ai.
Tier Comparison
Price and Priority
| Tier (slug) | Billing | Place on the ladder | Scheduling priority |
|---|---|---|---|
Free (free) |
No charge | Evaluation limits | Lowest |
Bulk (bulk) |
Per token | Lowest metered rate | Lower: behind the interactive tiers |
Base (base) |
Per token | Entry interactive rate | Interactive |
Plus (plus) |
Per token | Mid-ladder interactive rate | Interactive |
Max (max) |
Per token | Top interactive rate | Interactive |
Self-Hosted (self_hosted) |
Hourly per EIM, plus per uncached token | Your own EIMs | Highest |
Cached tokens on the metered tiers bill at a fraction of the per-token rate. See Cached Token Pricing.
Limits
Every tier sets the same list of limits; the values differ by tier. Limits by Tier lists each tier's current values. A limit the tier leaves unset is unlimited.
| Limit | What it caps |
|---|---|
| Endpoints | Endpoints a project can hold. Checked when an endpoint is created, from the dashboard, the management API, or erectl; the refusal names the cap. Unspent purchased credit or a live subscription lifts it; free and referral credit does not. |
| Endpoints per task mode | Endpoints a project can hold for one task mode (generate, embed, score, transcribe, speech). Checked on the same paths as the endpoint cap, and lifted the same way. |
| Uploaded models | Models a project can upload. Unspent purchased credit or a live subscription lifts it. |
| Max model size | The largest model an endpoint on the tier can serve. Checked when an endpoint is created, on every create path. Nothing lifts it. |
| Workspace storage cap | Bytes a workspace can store when the workspace carries no override of its own. |
| Request timeout | The deadline for one request. |
| Stream idle timeout | The longest gap between streamed chunks before the stream is closed. |
| Completion hot-cache retention | How long a stored completion stays in the hot cache before reads go to object storage. See Completion Storage. |
Streaming is available on every tier.
Limits by Tier
Each tier's current limits, read from the live catalog. Only tiers with live capacity are listed. The endpoint and uploaded-model caps hold until the project has unspent purchased credit or a live subscription; free and referral credit does not lift them. Max model size is never lifted.
| Tier | Endpoints | Uploaded models | Max model size | Request timeout | Stream idle timeout |
|---|---|---|---|---|---|
Free (free) |
4 (1 per task mode) | 2 | 64 GB | 30s | 120s |
Bulk (bulk) |
Unlimited | Unlimited | 20 GB | 600s | 600s |
Base (base) |
Unlimited | Unlimited | Unlimited | 300s | 600s |
Plus (plus) |
Unlimited | Unlimited | Unlimited | 300s | 600s |
Max (max) |
Unlimited | Unlimited | Unlimited | 600s | 600s |
Self-Hosted (self_hosted) |
Unlimited | Unlimited | 512 GB | 1800s | 3600s |
Tier Details
The paid platform tiers form a price ladder. Bulk is the cheapest metered rate and yields to interactive traffic; Base, Plus and Max share interactive scheduling priority and differ by rate and by the limits set on each. No tier names a vendor: which EIMs serve a tier is set per EIM, and any of them may be NVIDIA, AMD, Intel, Apple or CPU.
Free (free)
Evaluation limits and the lowest scheduling priority. Your first project receives a credit grant every cycle while it has no payment method on file. The right tier for evaluating the routing surface and proving an SDK call works.
- Billing
- No charge
- Scheduling priority
- Lowest
- Limits
- Evaluation limits on endpoints, models and model size
Bulk (bulk)
Lowest metered rate. Scheduled behind the interactive tiers; built for volume and background work.
- Billing
- Per token, the lowest metered rate
- Scheduling priority
- Lower: behind Base, Plus and Max
Base (base)
Entry metered rate for interactive traffic on the shared fleet.
- Billing
- Per token, the entry interactive rate
- Scheduling priority
- Interactive
Plus (plus)
Mid-ladder metered rate for interactive traffic on the shared fleet.
- Billing
- Per token, the mid-ladder interactive rate
- Scheduling priority
- Interactive
Max (max)
Top metered rate for interactive traffic on the shared fleet.
- Billing
- Per token, the top interactive rate
- Scheduling priority
- Interactive
Self-Hosted (self_hosted)
Your EIMs, your infrastructure. Billed an hourly rate per enrolled EIM for the hours it is connected, plus a per-token rate on the uncached tokens your EIMs serve: input and output alike, with your plan's per-token rate on top. Cached input tokens are free. EIMs are pinned to the project. One EIM drives one accelerator or many, and several EIMs can share a machine, so you decide how your accelerators are split.
- Hardware
- Your own EIMs, any vendor or form factor
- Scheduling priority
- Highest
- Billing
- Hourly per EIM, plus per uncached token; cached input free
Note on hardware matching. Like every tier, Self-Hosted carries no hardware constraint of its own. Self-hosted endpoints are bound to specific EIMs, and each EIM is checked when it is bound: the model must fit that EIM, as described under Hardware Requirements. Unless the endpoint declares a hardware requirement such as an architecture class or NVLink, it stores no VRAM floor or GPU count, so a CPU EIM or one large GPU qualifies whenever the model fits it. Size self-hosted clusters for the models you serve.
Tier Selection
The service tier is configured per endpoint in the Erebine dashboard or API. When you create or update an endpoint, you select which tier it uses. All requests to that endpoint are routed to EIMs serving the configured tier that also satisfy the endpoint's hardware requirement.
The endpoint's configured tier always determines which EIM pool is eligible
to serve a request; it cannot be overridden per request. The OpenAI-compatible
service_tier request parameter does, however, select a processing
lane within the configured tier. It accepts OpenAI's values
(auto, default, flex, scale,
priority); each resolves to one of three lanes:
service_tier value |
Routing score adjustment | Token billing |
|---|---|---|
flex |
-15 (de-prioritized against other in-flight work) | Below the standard per-token rate |
default, auto, scale, omitted, or unrecognized |
No adjustment | Standard per-token rate |
priority |
+15 (preferred against other in-flight work) | Above the standard per-token rate |
The resolved lane -- flex, default, or
priority, never auto, scale, or a tier
slug -- is returned in the service_tier field of every response:
chat completions (every streaming chunk and the non-streaming body), Responses
API objects and events, and embeddings. Both prompt and completion tokens are
billed at the lane's multiplier on top of the endpoint tier's per-token rate; cached
tokens are still discounted by the tier's cached token multiplier before the
lane multiplier is applied.
The router selects backends within the configured tier using configurable routing strategies:
- Least Loaded, Prefer EIMs with the lowest queue depth.
- Lowest Latency, Prefer EIMs with the lowest predicted latency.
- Model Affinity, Prefer EIMs that already have the model loaded.
- Round Robin, Cycle through available EIMs evenly.
- Composite, Weighted combination of multiple strategies.
You can also pass optional X-SLO-TTFT-Ms and X-SLO-TPOT-Ms
request headers to hint at latency targets. The router boosts preference for EIMs
likely to meet these targets. See the
SLO Tracking documentation for details.
Hardware Requirements
Hardware needs come from the workload, never from the tier. Any tier can hold any mix of NVIDIA, AMD, Intel, Apple and CPU EIMs, and one endpoint can be served by that mix. An EIM serves an endpoint only when it passes every check below:
- Model fit, per EIM, Checked when an EIM is bound to the endpoint and again whenever the router places the endpoint on an EIM. On a GPU EIM the model's weights and KV cache must fit the EIM's GPU memory; on unified-memory hardware such as Apple silicon, shared system memory counts as GPU memory. On a CPU EIM the model's parameter count must be within what the EIM can run. A bind the model does not fit is refused with the reason, and placement passes over that EIM.
- Architecture class, A minimum GPU architecture generation the operator declares on the endpoint, for models that depend on generation-specific kernels.
- NVLink, An NVLink interconnect between GPUs the operator declares on the endpoint, for multi-GPU workloads sensitive to interconnect bandwidth.
- Model-specific constraints, Speech and image generation endpoints are served only by EIMs that serve the task mode, which takes vLLM-Omni, on NVIDIA, AMD and Intel GPUs alike. An image generation model also needs each GPU to have the memory its pipeline loads in.
An endpoint that declares an architecture class or NVLink also carries the model's minimum VRAM per GPU and minimum GPU count, derived from its parameter count, quantization and context length, so only GPU EIMs that meet all of them serve it. An endpoint that declares no hardware requirement stores no VRAM floor or GPU count, so a CPU EIM or one large GPU can serve it whenever the model fits. Declared requirements are evaluated against the capability each EIM reports and refreshes while connected, so a fleet change takes effect without redeploying the endpoint.
Tier membership is explicit: an EIM serves exactly the tiers set on it, and its detected hardware never adds or removes one.
macOS Integration
Apple Silicon Macs (arm64, macOS 26+) integrate natively via the Erebine desktop application. The app installs, configures, and controls an EIM with Metal-accelerated vLLM in a single window -- no container or admin password required. Once enrolled with a join key, the Mac appears under System -> EIMs and EEMs and runs a shared-workload EIM for the project.
The native path uses Apple Metal (not CUDA/ROCm) and declares
appleMetal as its accelerator class. Unified memory
is shared between CPU and GPU, and it counts as GPU memory when the
router checks whether a model fits the Mac (see
Hardware Requirements). See
EIM on macOS for the full deployment
guide.
Cached Token Pricing
When prefix caching is active and input tokens are served from the KV cache
(reported as prompt_tokens_details.cached_tokens in the usage
object), those tokens are billed at a reduced rate. Each metered tier carries
a cached_token_cost_multiplier: the fraction of that tier's full
per-token price charged for a cached token.
| Tier | Cached Token Multiplier |
|---|---|
| Free | Not applied: no token meter |
| Bulk, Base, Plus, Max | Set per tier; applied to that tier's per-token rate |
| Self-Hosted | None: cached input tokens are free |
Maximizing your prefix cache hit rate directly reduces your token costs. See Prefix Caching for the cost formula, a worked example, and prompt structuring recommendations.
Custom Models and Tier Restrictions
Custom models, models that you upload and manage privately within your project --
are restricted to the Self-Hosted tier. To use a model on the shared
platform tiers (Free, Bulk, Base, Plus, or Max), the model must be published to the public catalog
and promoted to the shared catalog role.
This restriction ensures that shared infrastructure only runs models that have been explicitly published and vetted. Private models never run on shared EIMs.
| Model Type | Allowed Tiers |
|---|---|
| Custom (private, not in catalog) | Self-Hosted only |
| Catalog model (deployable role) | Self-Hosted only |
| Catalog model (shared role) | All tiers |
Catalog Roles and Tier Access
Models in the public catalog are assigned a catalog role that controls which tiers they can be deployed on:
- Deployable: The default role for newly shared models. The model is visible in the catalog but can only be used with the Self-Hosted tier. Other users can see the model in the catalog but must deploy it on their own infrastructure.
- Shared: The model is available on all tiers, including shared compute.
The catalog role is managed automatically by the platform based on the state of the shared-EIM model cache. There is no manual promotion endpoint and no operator workflow to flip the role directly:
-
When at least one shared EIM has the model cached and ready to serve, the
platform promotes the catalog role to
shared. -
When no shared EIM has the model cached, the platform demotes the catalog
role back to
deployable.
Because promotion follows shared-EIM cache state, the set of catalog models available on shared tiers can change over time as EIMs load, evict, or rotate models.
For details on how model sharing works and how to publish models to the catalog, see the Model Sharing documentation.
Completion Storage
When store: true is set in a request, the completion is saved for
later retrieval. Completions pass through two storage stages before expiration:
When store: true is set in a request, the completion is
saved. A hot tier cache fronts recently used content for fast
retrieval; older content is archived to object storage. Content is
retained as long as the project is funded - there is no
per-tier time-to-live. If the credit balance reaches zero, storage enters
a 96-hour grace window; settling the balance within it
removes nothing. See Pricing for the
storage rate and Credits
for the credit exchange.
Free Account Limits
Free plans grant credits every cycle to your first project (while it has no payment method and no active subscription). When the credit balance reaches zero, token requests halt; storage keeps its 96-hour grace window before removal. There is no per-month token cap. Storage is held to the 50 GB per-project default allowance; to request more, contact support.
Choosing a Tier
| Use Case | Recommended Tier |
|---|---|
| Testing and prototyping | Free |
| Batch jobs and background work where cost matters more than tail latency | Bulk |
| Interactive production traffic | Base, Plus, or Max: the same scheduling priority at different rates and limits |
| Models larger than Free's max model size | A paid tier whose max model size covers the model; Limits by Tier lists each one |
| Data sovereignty / compliance | Self-Hosted |
| Requests longer than a tier's request timeout | A tier whose request timeout covers them; Limits by Tier lists each one |
A higher tier does not buy different silicon. Hardware follows the model and the endpoint; see Hardware Requirements. The tier choice stays a price choice.
The dashboard sets an endpoint's tier when the endpoint is created.
To change it later, send tier_id to
PATCH /v1/management/endpoints/{id}.
Code Examples
The endpoint's tier is fixed at creation; these requests do
not select one. Pass an optional service_tier
body field (flex, default, or
priority) to nudge routing priority and billing
inside the configured tier
(see Tier Selection). The
response echoes the actual tier used.
Python (OpenAI SDK)
from openai import OpenAI
client = OpenAI(
base_url="https://api.erebine.ai/proj_ABC123/my-endpoint/v1",
api_key="ere_my-project_abc123"
)
response = client.chat.completions.create(
model="my-model",
messages=[{"role": "user", "content": "Hello"}]
)
print(response.choices[0].message.content)
# The service_tier field shows which tier processed the request
print(f"Service tier: {response.service_tier}")
Node.js (OpenAI SDK)
import OpenAI from 'openai';
const client = new OpenAI({
baseURL: 'https://api.erebine.ai/proj_ABC123/my-endpoint/v1',
apiKey: 'ere_my-project_abc123'
});
const response = await client.chat.completions.create({
model: 'my-model',
messages: [{ role: 'user', content: 'Hello' }]
});
console.log(response.choices[0].message.content);
// The service_tier field shows which tier processed the request
console.log(`Service tier: ${response.service_tier}`);
curl
curl https://api.erebine.ai/proj_ABC123/my-endpoint/v1/chat/completions \
-H "Authorization: Bearer ere_my-project_abc123" \
-H "Content-Type: application/json" \
-d '{
"model": "my-model",
"messages": [{"role": "user", "content": "Hello"}]
}'
# The response includes "service_tier" indicating the endpoint's configured tier