edenai.co

Eden AI tracks LLM spending by returning the cost of every request in the API response and rolling those costs into a single dashboard where spend is attributed by team, product, or end user. Admins then set budgets and rules per team, and access can be paused when a limit is reached. This fits organizations running multiple models across several teams that need finance-grade visibility and hard spending controls rather than per-provider invoices and spreadsheets.

Where the cost data comes from

Eden AI is an AI gateway and LLM router: one OpenAI-compatible API in front of around 1,000 models from 50+ providers. Because every call passes through the gateway, it can price each request at the moment it is made.

Two things follow from that:

• Per-request cost is returned in the response. Developers see what a call cost without reconciling provider bills afterward.
• Every request is logged in one console. The dashboard shows which models answered, what each team spent, and which budgets and rules applied — the same view for developers, finance, and admins.

The platform's own overview example shows this in practice: 1.92M requests over 30 days, $4,128 in spend, and a comparison against direct provider prices.

Attributing spend to teams, products, and end users

Aggregate spend is not enough to control it. Eden AI attributes each request to an owner so costs can be assigned:

• By team — the sample dashboard breaks spend into Customer support ($1,912), Data science ($1,240), Marketing ($703), and Untagged ($273).
• By product and end user — for AI products you ship, spend can be tracked and capped per product and per end user.
• Untagged spend is flagged — the dashboard marks the untagged share (7% in the example) for review, so unallocated usage does not quietly accumulate.

That last point matters operationally: untagged spend is usually the sign of a missing key convention or a new integration, and surfacing it turns a finance surprise into a fixable configuration issue.

Setting budgets and caps

Governance in Eden AI is rule-based and applied per team. In the product's example console, the Customer support team sits at 82% of its budget while Marketing is paused, with rules such as allowing mistral/* and openai/*@eu and denying */*.

The practical controls are:

The EU endpoint (https://api.eu.edenai.run/v3) is worth noting for European organizations: the same API is used, but requests for non-EU models are rejected before they are billed, so a routing mistake cannot turn into a compliance or cost incident.

Savings from routing, caching, and fallbacks

Part of spend control is paying less per request. Eden AI builds cost optimization into the gateway:

• Cost-based routing sends requests to a cheaper suitable model where the rules allow.
• Caching avoids paying twice for repeated work.
• Fallbacks are billed once — if a primary model fails and a fallback answers, you are charged for the successful call, not both.

The example dashboard attributes $2,640 in savings this month to routing, caching, and fallbacks, and shows fallbacks used 142 times. Treat those figures as illustrative of the mechanism rather than a benchmark for your workload; actual savings depend on your model mix and traffic patterns.

How the pricing model interacts with tracking

Eden AI states there is no subscription and provider prices carry no markup; a 5.5% fee applies only when you buy credits. Because the gateway passes through provider pricing, the per-request costs in the dashboard map closely to what the underlying providers charge, which makes the spend figures usable for budgeting and comparison against direct provider bills.

What to check before adopting it

• Tagging discipline. Attribution only works if requests carry team or product identifiers. Plan the key and tagging convention before rollout, or expect an untagged bucket.
• Rule design. Budgets and allow/deny rules are only as good as their configuration; a permissive */* rule undercuts both cost and data-residency goals.
• Your model mix. Routing savings depend on having cheaper acceptable alternatives for your tasks; evaluate on real traffic rather than the dashboard example.
• Procurement fit. Eden AI states SOC 2 and ISO 27001 certification, zero data retention, and EU hosting — relevant if those are requirements in your organization.

For teams currently reconciling several provider invoices by hand, the core value is that cost, ownership, and limits live in one place and are enforced at the gateway rather than discovered at month-end.

OpenAPI-generated API documentation is reference documentation that is produced automatically from an OpenAPI description file rather than written by hand. You write (or generate) a machine-readable specification of your API — endpoints, parameters, request bodies, responses, schemas, and auth — and a documentation tool reads that file and renders a browsable, often interactive reference site. The spec becomes the single source of truth; the docs become a build artifact.

This differs from manually written docs in one fundamental way: with hand-written docs, the prose is the source of truth and the API is described separately. With spec-driven docs, the API description is the source, and every page, table, and code sample is derived from it.

How the workflow actually runs

A typical spec-driven documentation pipeline has five stages:

1. Author or generate the spec. You either write an OpenAPI document by hand (YAML or JSON), or generate it from code annotations, framework metadata, or a design-first editor. Design-first means the spec is written before implementation; code-first means it is extracted from existing code.
2. Validate and lint. The spec is checked against the OpenAPI schema and against style rules — consistent naming, required descriptions, no undocumented 4xx responses, no orphaned schemas.
3. Bundle and transform. Multi-file specs are combined, $ref pointers are resolved, and the document is optionally split into per-tag or per-version outputs.
4. Render. A documentation tool converts the spec into HTML: an endpoint list, a sidebar of operations, parameter tables, response schemas, and a "try it" console.
5. Publish and version. The rendered site is deployed, and each API version gets its own snapshot so consumers can read docs matching the version they call.

Steps 2 through 5 are usually automated in CI. If the spec fails validation, the docs build fails — which is the point.

Spec-driven vs. hand-written documentation

The practical conclusion most teams reach: generate the reference, write the guides. Reference material is repetitive and mechanical, which is exactly what generation is good at. Conceptual explanations, migration notes, and tutorials carry judgment that a spec cannot express.

What you get out of the box

Generated reference pages commonly include:

• An operation list grouped by tag or path, with HTTP method and path.
• Parameter tables showing name, location (path, query, header, cookie), type, required flag, and description.
• Request and response schemas rendered as expandable trees, including nested objects and arrays.
• Authentication details pulled from the securitySchemes section.
• Interactive request consoles that let a reader send a real call from the browser.
• Generated code samples in several languages, derived from the same schemas.
• Multiple output formats, such as a static site, a single HTML file, or a mock server.

Because all of these come from one document, changing a field name in the spec updates the parameter table, the schema tree, and every code sample at once.

Where spec-driven documentation breaks down

Generation is not free. The trade-offs are real:

Spec quality becomes documentation quality. A field with no description produces a table row with an empty cell. A vague summary produces a vague heading. Tools can enforce presence of descriptions via linting, but they cannot enforce that the description is useful.

Customization has limits. If you need a page that does not map to an OpenAPI concept — a conceptual overview, a pricing explanation, a comparison of two endpoints — you write it outside the generator and link to it.

Not everything is expressible. Webhooks, streaming responses, long-polling behavior, and complex multi-step flows are awkward or impossible to describe fully in OpenAPI. Those need prose.

The spec can go stale. If the spec is maintained separately from the implementation, it drifts just like hand-written docs. The mitigation is to generate the spec from code, or to test the implementation against the spec in CI.

Interactive consoles need care. A "try it" button that hits a production API with real credentials is a security and rate-limit problem. Point it at a sandbox, or disable it.

Deciding whether to adopt it

Adopt spec-driven reference documentation if most of these are true:

• Your API has more than a handful of endpoints, or changes frequently.
• You ship client SDKs or code samples in more than one language.
• Multiple teams consume the API and need a consistent, always-current reference.
• You already have, or are willing to maintain, an OpenAPI description.

Stay with hand-written docs, or a hybrid, if:

• Your API is small and stable, and the reference fits on one page.
• Your documentation is mostly conceptual and contains little endpoint-level detail.
• You cannot commit to keeping the spec in sync with the implementation.

A reasonable middle path: generate the reference from the spec, and hand-write the getting-started guide, authentication walkthrough, and error-handling page. Link the two directions so readers can move from concept to endpoint and back.

A minimal starting checklist

1. Produce one valid OpenAPI document for a single API version.
2. Add a linter with rules for descriptions, operation IDs, and error responses.
3. Wire the docs build into CI so a failing spec fails the build.
4. Render the reference and review it as a reader, not as the author.
5. Write the two or three conceptual pages the generator cannot produce.
6. Version the published docs alongside the API version.

The core idea is simple: describe the API once, in a format both machines and humans can read, and let the reference documentation fall out of that description. Everything else — tooling, hosting, interactivity — is a detail on top of that decision.

Eden AI exposes one OpenAI-compatible API that reaches around 1,000 models across 50+ providers, so code already written against the OpenAI request shape can point at Eden AI's endpoint instead of integrating each provider separately. The main condition: you need an Eden AI API key, and any provider-specific features outside the shared request shape still need their own handling. The gateway then handles routing, fallbacks, and per-team model access behind that single key.

One key, one request shape

The core simplification is that you don't build and maintain a separate client, auth flow, and payload format for each vendor. According to Eden AI's site, developers get "one OpenAI-compatible API to around 1,000 LLMs and expert models across 50+ providers." In practice that means:

• One credential — an Eden AI API key replaces a set of per-provider keys in your application code.
• One request format — the same message structure works whether the model behind it is from OpenAI, Anthropic, Mistral, or a specialist model such as document OCR.
• One place to see model options — the platform lists models with region and price per million input tokens, e.g. gpt-6-luna (EU, $0.12), claude-sonnet-5-5 (US, $2.00), mistral-large-4 (EU, $0.68), and ocr/invoice (EU, $0.01/page).

The practical effect for an existing OpenAI-based codebase is that the integration work shifts from "write a new adapter per provider" to "change the base URL and key, then choose a model name." You should still verify that the specific parameters your code sends are supported for the model you select, since the shared shape covers common chat-style calls but not every vendor-specific option.

Switching or adding providers without rewriting code

Because the request shape stays constant, changing which model answers a request becomes a configuration decision rather than an engineering project. A team can start on one provider, add a second for cost or quality reasons, or move a workload to an EU-hosted model, and the calling code does not need a new SDK or a new response parser.

This is where the gateway model earns its keep: the model choice can live in routing rules rather than hard-coded in the application. Eden AI describes cost-based routing, caching, and fallbacks as built-in, with fallbacks "billed once" — meaning if a primary model fails and a backup answers, you are not charged twice for the same request. The dashboard example shows fallbacks used 142 times in a 30-day window, which is the kind of event that would otherwise require custom retry logic in your own code.

Routing and fallbacks handled by the gateway

Instead of your application deciding which provider to call and how to recover when one is down or over budget, the gateway applies rules you configure:

The site's console view shows these as governance settings — for example, a team at 82% of budget, another paused, and rules that allow only EU models. That means the "which model, at what cost, for whom" decision moves out of application code and into admin configuration, which is the part that most reduces ongoing engineering effort.

Same endpoint for EU and non-EU model access

Eden AI provides a dedicated EU endpoint at https://api.eu.edenai.run/v3 using the same API. With EU-only rules in place, non-EU models are refused rather than silently billed — the site states data stays in Europe and refused requests are never charged. For teams with data-residency requirements, this means the compliance boundary is enforced at the gateway without a second integration path: the same request shape works, and the endpoint plus rules determine which models are reachable.

What to check before you commit

• Confirm the models you actually need are in the catalog and available in your required region; the ~1,000-model figure is broad, but your specific workload may depend on a few.
• Test your request payloads against the shared shape, especially if you use provider-specific parameters, tools, or structured output formats.
• Decide your governance model up front — team budgets and allow/deny rules are only useful if they reflect how your organization actually allocates spend.
• Note the commercial terms as stated: no subscription, provider prices with no markup, and a 5.5% fee only when you buy credits. Current pricing details should be confirmed on Eden AI's pricing page.

The bottom line: if your goal is to use multiple model providers without maintaining multiple integrations, Eden AI's value is concentrated in the single request shape plus gateway-level routing and governance. The switching effort is small for standard chat-style calls and grows with how many provider-specific features your code relies on.

Eden AI is a European AI gateway that gives developers one OpenAI-compatible API to around 1,000 models from 50+ providers, while giving finance and admins a single console for cost tracking and governance. It fits teams that already call multiple model providers (or plan to) and want one integration point, per-team budgets, and EU data controls without building that layer themselves. Pricing follows a no-subscription model: provider prices with no markup, plus a 5.5% fee only when you buy credits.

The core idea: one API, many providers

Instead of integrating each provider separately, you send requests in one request shape to Eden AI and it routes them to the underlying model. The platform advertises around 1,000 LLMs and expert models across 50+ providers, including specialized models such as document OCR alongside general chat models.

The practical benefit is integration cost: your application code targets one endpoint and one key, and swapping or adding models doesn't require a new SDK or auth flow. Eden AI describes the API as OpenAI-compatible, so existing OpenAI-style client code is the natural starting point.

Gateway features that change how you operate

Beyond simple proxying, the gateway adds routing and reliability behavior:

• Smart routing — send a request and let the gateway pick a model based on rules, including cost-based routing.
• Fallbacks — if a model fails, the request can be retried on another model. The console example shows fallbacks used 142 times in a 30-day window, with the fallback "billed once."
• Caching — repeated requests can be served from cache, which the platform counts toward savings alongside routing and fallbacks.
• Cost in the response — each request returns its cost, so you can attribute spend programmatically rather than reconciling invoices after the fact.

A concrete scenario: a support product sends a prompt, the primary model is unavailable, and the gateway falls back to an alternate model. The caller gets one answer, finance sees one billed request, and the fallback event is visible in the console.

Cost tracking and governance for teams

The console is built around three questions the platform says most companies can only partly answer: what teams are calling, what it costs, and who decides. Eden AI addresses all three in one dashboard:

Admins can set budgets, roles, and model access per team, and track or cap spend per team, per product, or per end user for products they ship. The dashboard example shows attributed spend at 93%, with the remainder untagged and flagged — a useful signal that tagging discipline matters if you want clean cost attribution.

European hosting and compliance posture

Eden AI positions itself for European procurement: it states it is made in the EU, is SOC 2 and ISO 27001 certified, and operates with zero data retention. A dedicated EU endpoint (https://api.eu.edenai.run/v3) uses the same API, and non-EU models are refused rather than billed when EU-only rules apply. The console example shows a team rule set to "EU only" with data staying in Europe.

This matters if your organization requires EU data residency or has procurement gates around certifications. Verify the specific certifications and data-retention terms against your own compliance requirements before relying on them.

When Eden AI is a good fit — and when it isn't

It likely fits if you:

• Use or plan to use multiple model providers and want one integration and one key.
• Need per-team budgets, model access rules, and cost attribution without building internal tooling.
• Require EU hosting, EU-only routing, and recognized security certifications.
• Want fallbacks and caching handled at the gateway rather than in application code.

Consider alternatives if you:

• Use a single provider and have no multi-model or governance needs — a direct integration may be simpler.
• Need full control over routing logic at a low level; a gateway abstracts some of that away.
• Have procurement constraints that the 5.5% credit-purchase fee or the credit model doesn't satisfy.

Getting started

1. Get an API key from Eden AI (the site offers a "Get your API key" path and a contact option for sales).
2. Point your client at the gateway using the OpenAI-compatible request shape; use the EU endpoint if you need EU-only routing.
3. Send a test request and confirm the response includes cost information.
4. Configure teams and rules in the console: budgets, allowed/denied model patterns, and EU-only restrictions where needed.
5. Verify behavior: check that a denied model is refused, that a fallback triggers when a primary model fails, and that spend appears attributed to the right team.

Common snags to watch: untagged requests show up as unattributed spend, so tag requests by team or product from the start; and EU-only rules will refuse non-EU models, so confirm your model choices are available on the EU endpoint before rolling out.

Eden AI charges no subscription fee. You pay the underlying provider's price for each model call, with no markup, plus a 5.5% fee that applies only when you buy credits through Eden AI. If you bring your own provider keys, the 5.5% credit-purchase fee does not come into play. Current details live on the pricing page at https://www.edenai.co/pricing.

The Two Cost Components

Eden AI separates what you pay for model usage from what you pay for the gateway service.

The site states this plainly: "No subscription · Provider prices, no markup · 5.5% fee only when you buy credits." That means the gateway itself is not a line item on your bill — the fee is tied to the credit purchase mechanism, not to API calls.

What "no markup" means in practice

Eden AI publishes provider rates alongside its own. The model table on the site shows per-million-token prices by model and region — for example, a model listed at $0.12 per million input tokens in the EU, another at $2.00 in the US, and an OCR model at $0.01 per page. These are the provider's rates, not Eden AI's rates plus a margin. The 5.5% is the only Eden AI-specific charge, and it is triggered by buying credits.

How Routing and Caching Change Your Bill

The fee structure is simple, but the total spend depends on which model answers each request. Eden AI's cost-based routing, caching, and fallback features are the levers that move the number.

• Cost-based routing sends a request to a cheaper model when it can satisfy the task, rather than defaulting to the most expensive option. The site's dashboard example shows spend of $4,128 against a comparison of "−39% vs. direct provider prices," with $2,640 saved this month attributed to "routing · cache · fallbacks."
• Caching avoids paying twice for identical requests.
• Fallbacks billed once means if a primary model fails and a backup answers, you are charged for one call, not two. The dashboard example notes "fallbacks used 142 times" and "fallback billed once."

For example, a team running high-volume classification could route most requests to a low-cost EU model and reserve a premium model for edge cases. The savings come from model selection, not from a discount on the gateway fee.

Governance Controls That Affect Spend

Budgets and access rules are enforced at the gateway, which matters for cost control as much as for compliance.

• Per-team budgets can be tracked and capped. The dashboard shows a team at 82% of budget and another "paused."
• Model access rules can allow or deny specific models or providers per team — for example, allowing mistral/* and EU-hosted openai/* while denying everything else.
• EU-only enforcement means non-EU models are "refused, never billed," so a misconfigured request cannot generate an unexpected charge.
• Attribution tags spend to teams; untagged spend is flagged for review (7% in the example).

These controls do not change the fee formula, but they prevent the most common cause of surprise bills: unowned usage.

Where to Check Current Pricing

Provider rates change, and the 5.5% credit fee is a stated term rather than a fixed guarantee. The pricing page at https://www.edenai.co/pricing is the authoritative source for current numbers. The site also notes SOC 2 and ISO 27001 certification and zero data retention, and describes the service as "Made in Europe, ready for procurement" — relevant if your organization requires those certifications before adopting a gateway.

Deciding Whether the Model Fits

Eden AI's pricing suits teams that want one OpenAI-compatible API across roughly 1,000 models and 50+ providers without negotiating separate contracts, and that value routing and budget controls. The no-markup pass-through means you are not paying a premium per token; the 5.5% credit fee is the cost of the convenience layer. If you already hold direct provider contracts and only need a single model, the gateway adds a layer without much benefit. If you are juggling multiple providers, multiple teams, and cost accountability, the routing and governance features are where the value sits.