# Hosted sources

> Sell inference from a cloud account without running a machine. The platform serves through your own upstream API key; you pay the upstream and customers pay you.

Source: https://0.0.0.0:3000/docs/providers/hosted
Documentation index: https://0.0.0.0:3000/docs/llms.txt

A hosted source is a cloud inference account, such as OpenRouter, that the platform serves for you. You connect it in the dashboard with your own API key, choose models and prices, and the platform handles every request through your account. There's no agent to install and no machine to keep online.

If you don't see the **Hosted** option when you create a provider, use a [self-hosted](/docs/providers/quickstart) agent instead; it supports the same cloud connectors and more.

## Hosted or self-hosted

| | Hosted | Self-hosted |
| --- | --- | --- |
| Where serving runs | On the platform | Your machine, next to your models or keys |
| What you manage | An API key and your model list, in the dashboard | The `numes` executable, its profiles and uptime |
| Sources | [Supported cloud connectors](#supported-connectors) | Local engines, any OpenAI-compatible server, every cloud connector |
| Upstream sign-in | API key, or **Sign in with OpenRouter** | API key |
| Custom upstream addresses | No | Yes |
| Hosted tools executed by the upstream | No | Yes, where the source supports them |

You choose per provider when you create it, and can't change it afterwards. A hosted provider serves only hosted sources, and a self-hosted provider serves only agent endpoints. To use both, create one provider of each kind under the same account.

## Connect a source

:::steps
### Create a hosted provider

Open [Provider › Overview](/dashboard/provider) and choose **Become a provider** or **New provider**. Enter the name customers will see and choose **Hosted** (**Your API key**) under **How you'll serve**. The provider enters review when you continue; you can connect sources and choose models while it's pending.

### Connect your upstream

Pick the **Upstream** and name the endpoint. Then either:

- paste the upstream API key, or
- for OpenRouter, choose **Sign in with OpenRouter** to authorize in the browser. OpenRouter issues a key, and the dashboard stores it.

The key is encrypted as soon as it's received and is never shown again. The platform checks the key without running inference, then fetches the upstream's supported chat models. The dialog distinguishes a rejected key from a check that couldn't complete. A failed replacement keeps the current key. If no supported chat models are available, the connection stays saved and **Choose models** is disabled.

Model limits and capabilities come from the upstream where it reports them, with reviewed metadata and conservative defaults filling the gaps. OpenCode Zen models need a known API dialect.

### Choose models and prices

Choose **Choose models**. Select the models you want to sell, check each proposed public `author/model` name, and set prices. Every proposed name is reviewed by the platform. If a model has no proposed name, choose **Edit** on its row and enter a **Public model ID** in `author/model` form.

**Offer and pricing**, above the model list, applies to every model at once:

1. **Who can use them**: the open market, or, for a provider owned by an organization, shared free with its members. Members call a shared model as `author/model:org-<handle>`; shared models leave the open market and need no prices.
2. **How prices are set**: **I set the prices** starts every model at the upstream's list price, which is what each request costs you, and lets you change any model. **Autopilot** prices every served model from the upstream instead; see [Autopilot](/docs/providers/autopilot#start-a-hosted-endpoint-with-autopilot). **Add a markup** sets a percentage added to the upstream's list price and, for models whose reference is a market price, a percentage (which may be negative) applied to what other hosts charge. **Remove** sets both back to 0%.
3. **Accept payment in**: US dollars, Bitcoin or both. With Bitcoin and your own prices, choose whether the Bitcoin price follows the USD price at the live rate or is fixed in sats.

The model list shows each model's price and its origin ("OpenRouter + 15%", **Custom price**, **Autopilot**, **Price not set**), or, for a published model, what your draft changes ("Input $3 → $2.50"). **Select all** selects every model that matches your search and filters.

A model's editor shows all its rates, including image input, cache read, cache write, reasoning and per request, and lets you override its currencies. **Reset to** returns a typed-over price to the page's rule. With **I set the prices**, **Autopilot for this model** lets autopilot price only that model. **Changes since last submission** compares a published model with your draft. Some upstreams, such as PPQ.ai, list only input and output prices.

You can leave these rates blank:

| Rate | Left blank |
| --- | --- |
| Cache read, cache write | Charged at the input rate, so there's no cache discount |
| Reasoning | Charged at the output rate |
| Image input | Remains available on token-priced chat where the upstream reports image processing in prompt tokens |
| Per request | No per-request charge |

Entering `0` instead makes a separately priced quantity free. With token-priced vision chat, the input price covers image usage included in upstream prompt tokens. A separate image price requires a qualified image-count receipt. Input and output prices are always required.

### Publish

Choose **Publish your models**. Each model goes live once its public name and prices are approved, usually within a minute. Hosted models skip the technical verification that self-hosted offers need.

The model details show **Not required for hosted models** under **Last check** when no check is in progress and no recovery check is needed. Serving status still requires fresh health and capacity reports from the hosted endpoint.

If your provider is still in review, the button reads **Submit for approval**, and the platform approves your provider and its models together. Once the provider is approved, the endpoint starts, and each model goes live when its name and prices are approved. Submitting again replaces the earlier selection.
:::

If publication reports that a model must match its discovered template, choose **Refresh model list**, review the model's current capabilities and prices, and publish again. The error names the model by its position in the submitted list (`data[0]` is the first).

The provider is reviewed as for self-hosted providers. Hosted endpoints use a reviewed template for their connector, so they don't wait for a separate endpoint review. Public model names and prices go through the same [review](/docs/providers/lifecycle) as self-hosted models, and the platform may re-review any provider, endpoint or offer at any time.

## Supported connectors

| Connector | Credential | Notes |
| --- | --- | --- |
| OpenRouter | API key or **Sign in with OpenRouter** | Router models (`openrouter/*`) and models with variable prices aren't offered. |
| OpenAI | API key | Chat models from the live inventory. |
| Anthropic | API key | Chat models from the live inventory. |
| Google Gemini | API key | Chat models from the live inventory. |
| Kimi Code | API key | Chat models. |
| OpenCode Zen | API key | Models with a known API dialect. |
| PPQ.ai | API key | Models with variable prices aren't offered. |
| DeepInfra | API key | Chat models from the live inventory. |
| Novita AI | API key | Chat models. |
| Venice | API key | Chat models. |
| Venice E2EE | API key | End-to-end encrypted text chat; a separate choice from Venice. |
| Tinfoil | API key | End-to-end encrypted text chat. |

Every provider can create OpenRouter, OpenAI and Anthropic sources. The other connectors are limited to platform administrators; the **Upstream** menu shows the connectors you can create. Existing sources keep running if that access changes.

Hosted sources serve chat with text output, including function tools, reasoning, structured output and image input where the model supports them. Supporting a connector doesn't mean every model it lists. Hosted operation doesn't include:

- custom or proxy upstream addresses; every request goes to the connector's official address;
- private resources such as upstream file or vector-store IDs;
- tools executed by the upstream (hosted tools);
- embedding, image, speech and transcription models;
- local engines such as Ollama, vLLM and llama.cpp.

Encrypted models from Tinfoil and Venice E2EE keep their `:e2ee` IDs when published hosted. See [Encrypted inference](/docs/inference/encrypted) for their security guarantees and how customers use them.

## What it costs you

You pay the upstream for every request you serve. Customers pay your price for inference, and your full price is credited to your earnings; the platform fee is charged when customers buy credits. See [Pricing your models](/docs/providers/pricing#what-customers-pay).

Hosted models skip routine verification. If a model keeps failing on real traffic, routing stops sending it requests and the platform sends a short recovery check through your key; the model serves again once a check passes (see [recovery after repeated failures](/docs/providers/lifecycle#recovery-after-repeated-failures)). Recovery checks use your upstream account and earn nothing. Changing prices doesn't skip a model's recovery.

When the upstream reports no context length or maximum output for a model, discovery fills them from public model catalogues for the suggested public name, where your deployment enables the reference catalogue, and the model's details label them **from catalogue**. They're published like the model's other discovered terms. A catalogue suggestion that would conflict with a limit the upstream reports is skipped for that model. If a model's maximum output is larger than its context, the picker blocks publishing it and shows both limits.

Discovery shows **reference prices** so the price form can start from them: the upstream's own list prices where it reports them, otherwise a price from public model catalogues, labelled with its origin and age (see [reference prices](/docs/providers/pricing#reference-prices-and-markup)). A reference price is only a starting point; customers are never charged it unless you save it as your price. Set a markup that covers your upstream cost, including any upstream fees for cache writes or reasoning, or you'll serve at a loss. [Autopilot](/docs/providers/autopilot) can keep your prices at the upstream cost plus your markup, and its cost guard holds a model from customers while the upstream charges more than your live price.

## Capacity

The default allowance is 50 active hosted endpoints and up to 500 saved sources per account, shared across its hosted providers. Deployment settings and approved account allowances may differ. Existing accounts keep their approved active-endpoint allowance when the default changes; contact support to request an increase. Platform-wide capacity limits still apply.

Hosted capacity is shared, so each account has limits on active hosted sources, saved sources and concurrent hosted requests. The dashboard shows the limits for your account. Activation may be refused when capacity is short; try again later.

Each endpoint has a concurrency limit shared by all its models. There's no guaranteed throughput or request queue: when capacity is unavailable, the request is refused and routing can try another provider. Your upstream's own rate limits and quota still apply.

### Increasing capacity

1. If you need more than your account allows, contact support. Our team can raise the allowance for active endpoints and concurrent requests after reviewing capacity. The allowance is shared across all hosted endpoints in your account.
2. On your provider page, open the endpoint's actions menu and choose **Edit capacity**. Enter the number of concurrent requests and choose **Save capacity**. Use **Refresh allowance** after our team raises your allowance.
3. Choose **Review model capacity**, then **Refresh model list**. If the endpoint is paused, resume it first.
4. Review the **New capacity** changes and **Publish**. Your model selection, prices and access settings are kept. Published models keep their previous limits until the new revision goes live.

A lower limit applies to new requests; requests already running continue.

## Managing a hosted source

The platform refreshes upstream model capabilities in the background. If the upstream reports a limit below your published one, that model stops serving until a later refresh shows the upstream meets your published terms again. Refreshes never change your published capabilities or prices; to adopt changed upstream metadata, choose **Refresh model list**, review the changes and publish again.

Each hosted endpoint offers the actions its current state allows:

| Action | Effect |
| --- | --- |
| **Choose models** / **Edit models** | Change the model list, prices or accepted currencies and publish a new revision. |
| **Autopilot settings** / **Check now** | Turn [autopilot](/docs/providers/autopilot) on or off, change its markup, models and cost guard, or, while it's on, ask for a price check. |
| **Edit capacity** | Change the endpoint's concurrent request limit within your account allowance. |
| **Replace key** | Submit a new upstream key. The endpoint keeps serving with the current key until the new one passes its check. |
| **Pause** / **Resume** | Stop or restart serving. Pausing refuses new requests immediately and lets running ones finish. |
| **Delete** | Remove the source. Deleting a source that holds a stored key requires a recent sign-in. |

If the upstream rejects your key while serving, the endpoint stops and shows `key_rejected`. Other upstream failures show `source_failed` with the upstream's error code; check it before changing keys. A model-specific access error never marks the whole key invalid.

An upstream account without credit keeps a valid key, so the source keeps running, but its requests fail and fall back to other providers. Routing then rests the endpoint and retries it automatically, and the endpoint shows **Not serving** with `upstream_funding_required`. Top up the upstream account; the endpoint serves again on its own. See [Upstream account problems](/docs/providers/lifecycle#upstream-account-problems).

A source connected by an organization member keeps working if that member leaves the organization, but any setup they hadn't finished is cancelled.

## How keys are protected

- Keys are encrypted at rest, decrypted only to serve your requests, and never shown in the dashboard, logs or email.
- Requests go only to the connector's official address.
- Your dashboard sign-in, the platform's serving credentials and your upstream key are separate. Revoking one doesn't expose another.
- Keys on draft sources that were never enabled expire after 30 days without changes. Paused sources keep their keys.

## Next steps

:::cards
- {coins} [Pricing your models](/docs/providers/pricing) Markups, price protection and what customers pay.
- {badge} [Review and lifecycle](/docs/providers/lifecycle) Statuses, recovery and pausing.
- {wallet} [Earnings and payouts](/docs/providers/earnings) When earnings become available and how to withdraw them.
- {rocket} [Provider quickstart](/docs/providers/quickstart) Run your own agent instead, with any source.
:::