docs
// Features

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.

Limits for each service tier
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.

Shared Tier Caveats

Important: Shared models are subject to change. Models available on shared EIMs may be evicted or replaced at any time. Endpoints using shared models on shared tiers may become unavailable if the backing model is removed from shared infrastructure. For guaranteed availability and permanence, deploy the model on Self-Hosted infrastructure that you control.

Key considerations when using shared tiers with catalog models:

  • Model availability is not guaranteed. A model that is available on shared tiers today may be demoted to deployable-only tomorrow if shared EIMs evict it due to capacity constraints.
  • Endpoints may become unavailable. If the backing model is removed from shared infrastructure, endpoints on shared tiers will return 503 Service Unavailable until the model is re-provisioned or the endpoint is moved to the Self-Hosted tier.
  • Use Self-Hosted for critical workloads. If your application requires guaranteed model availability, deploy on the Self-Hosted tier, where you control the infrastructure and model lifecycle.
  • Monitor endpoint health. Use the dashboard or API to monitor endpoint provisioning status. If an endpoint shows as unprovisioned, the backing model may have been evicted from shared infrastructure.

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