Find the route details for your provider
A catalog entry that lists our model under our cloud provider still leaves our coding agent without an address to contact or a model identifier to send.
If either is wrong, the agent calls the wrong deployment or an API the model doesn't support. This article shows how we trace a Foundry, Bedrock, or OpenRouter entry to the fields a request needs. By the end we can fill in six route fields for the provider we chose and confirm the route with one authorized, harmless request.
A few terms carry the whole article. A provider is a service that exposes inference. An endpoint is an address our client contacts, and an API surface is the contract available at that address. We identify what should run inference by requesting a model or deployment, subject to the service's region, hosting, and access rules. Then we authenticate with a credential the route accepts.
The six fields we gather are:
- Provider
- API surface
- Endpoint
- Model or deployment
- Region
- Authentication
Region limits the endpoint and model or deployment choice, and the authentication method has to match the endpoint. Along with the provider label, we need route details such as Foundry's resource hierarchy and Bedrock's endpoint families.
A cloud service can host or proxy inference, and one endpoint can expose several contracts. So we use a model catalog for metadata and check separately whether the model is actually serving.
The sections below follow four steps:
- Learn how Foundry, Bedrock, and OpenRouter each define a route.
- Separate model facts from hosting facts in the catalog, and check two catalog prices against the provider's own page.
- Fill in the route fields for the provider we chose.
- Send one test request and record what came back.

Figure text
The lookup flow connects provider, API surface, endpoint, model or deployment, and region. The solid path shows route details. The dashed path shows a separate authentication check required by the endpoint.
- Six fields make a route
- Authentication, separate (dashed)
- A lit row: that field is filled in
- Six fields filled in. Nothing has been sent yet: one authorized, harmless request is what confirms the route serves.
- Coding agent
- Route card
- Endpoint
- API surface
- Provider
- Model or deployment
- Login
- Region
- 1 Provider; 2 API surface; 3 Endpoint; 4 Model or deployment; 5 Region; 6 Authentication
- offers
- targets
- Separately, the login has to be one this address accepts.
Sources: [1] Deploy and use Claude models in Microsoft Foundry - Microsoft Foundry | Microsoft Learn; [2] Claude in Microsoft Foundry - Claude Platform Docs; [3] API compatibility - Amazon Bedrock; [4] APIs supported by Amazon Bedrock - Amazon Bedrock; [5] OpenRouter API Reference - Complete Documentation.
How Foundry splits resources and deployments
On Foundry the route splits across a resource and a deployment, and the endpoint comes from the deployment.
For Claude in Microsoft Foundry, a resource holds security and billing configuration. A deployment is a model instance we call through the API, and one resource can contain more than one. The deployment's Target URI identifies the endpoint, and the deployment name can differ from the underlying model ID. Anthropic's Foundry provisioning guide separates resource and deployment choices.
The documented endpoint pattern is https://{resource}.services.ai.azure.com/anthropic/v1/*.
Here {resource} is a placeholder and * stands for operations under that path, so the pattern isn't a literal URL to call.
We take the actual Target URI from the deployment we select.

- A catalog entry, no address: a catalog entry that lists the model still leaves the coding agent without an address to contact or a model identifier to send.
- A resource and a deployment: on Foundry the route splits across a resource and a deployment.
- The pattern is not a literal URL: the documented endpoint pattern has a placeholder for the resource and a
*for the operations under its path, so it is not a literal URL to call. - The Target URI identifies the endpoint: the endpoint comes from the deployment, and we take the actual Target URI from the deployment we select.
The documentation lists API keys and Microsoft Entra ID tokens as authentication methods for Claude in Foundry.
The SDK's resource-name and base-URL options also differ by language, because the C# SDK does not read ANTHROPIC_FOUNDRY_BASE_URL and builds the base URL from the resource name.
We check Foundry authentication for the SDK we actually use.
Hosting option and region scope are separate entries. The documentation distinguishes Hosted on Azure from Hosted on Anthropic, and Global from eligible US Data Zone deployments, so we check which choices the exact model supports. Microsoft also conditions access on:
- subscription type
- billing geography
- deployment location
- Marketplace access
- permissions
After finding a catalog entry in our Azure account, we check whether the account meets Microsoft's prerequisites and subscription rules.
Bedrock has several APIs and endpoint families
Where Foundry's route question is mostly about the resource and deployment, Bedrock's is about which API surface and endpoint family the model is served through.
Bedrock uses different API names for different interfaces:
- InvokeModel gives us model-oriented control over requests and responses.
- Converse provides a common conversational interface for supported models.
- Responses, Chat Completions, and Messages are also API contracts, and the model and endpoint family decide which ones we can use.
AWS's API guide lists InvokeModel, Converse, Responses, Chat Completions, and Messages separately.
These two endpoint families list different APIs:
bedrock-runtimelists Invoke, Converse, Responses, Chat Completions, and Messages.bedrock-mantlelists Responses, Chat Completions, and Messages.
AWS documents two callable interfaces labeled Messages (AWS API guide).
On bedrock-runtime.{region}.amazonaws.com, Messages runs through InvokeModel using Anthropic's native request format, whereas the separate Messages API at bedrock-mantle.{region}.api.aws uses Anthropic-native request and response formats.
On bedrock-runtime, Responses requests are synchronous and have no server-side tools.
The Mantle Responses API supports asynchronous inference and server-side tools.
We check model support for Chat Completions and Responses separately from endpoint availability. Here is one row from the model compatibility table.
| Model | Invoke | Converse | Chat Completions | Responses | Messages |
|---|---|---|---|---|---|
| Claude Haiku 5.5 | Supported | Supported | Unsupported | Unsupported | Supported |
Bedrock offers Responses, yet the model compatibility row lists it as unsupported for this model. We separately check region and account access, along with current compatibility for the exact model, API, and endpoint we plan to use.
What OpenRouter normalization may ignore
OpenRouter sits in front of other providers, so we check how faithfully our request reaches the model.
OpenRouter exposes Responses at /api/v1/responses and Chat Completions at /api/v1/chat/completions.
Its reference describes normalized schemas across providers and models, and for tool requests it passes properties through to providers that use the OpenAI interface while transforming them for providers with custom interfaces.
The parameter behavior note says unsupported parameters may be ignored for the chosen model.
When our task depends on a tool or generation control, we test that control on the model and route we picked.
Model facts and hosting facts have different owners
The three providers above serve the same model with different controls, prices, and limits, and the models.dev catalog encodes that split in how it stores records.
The models.dev repository separates model-only records from provider-hosted records:
- Model-level metadata covers identity, family, and input or output modalities.
- Provider-hosted metadata covers how a service exposes the model, including reasoning controls, caching, pricing, and service tiers.
Serving metadata for the same model can vary by host. We check catalog capabilities and limits against the model maker's or provider's own docs.

Figure text
One labeled group contains model identity and modality fields; two others, one for each host, contain provider-specific reasoning, cache, and price fields. Model-level and provider-hosted metadata have separate owners.
- Model facts and hosting facts
- Lit row: a fact that group owns
- Dashed lane: check on outside page
- Two prices matched. The endpoint, region, tool support and context limit still get their own check, and if a catalog field disagrees with the provider we keep both values visible.
- 1 The model, hosted here
- 2 The same model, hosted elsewhere
- 3 Check against the provider's own page
- Model-level metadata: Model ID and family; Input and output modalities; Knowledge metadata
- Provider: Anthropic
- Provider-hosted metadata
- Another host
- Other host's metadata
- Provider's own pricing page
- The model
- Price check
- Reasoning controls; Cache behavior; Provider pricing
- Input: $3 per million tokens; Output: $15 per million tokens
- The same model
- We check the catalog against the provider's own page. Two prices, input and output: both match.
Sources: [1] models dev source.
Checking two catalog prices
To see the split in practice, we check one model's two catalog rates against the provider's own page.
Take Claude Sonnet 4.6 in models.dev revision 10e9ba979d98a79fb46d01b526282e90bbe7ba59.
The model-only record describes Claude Sonnet 4.6 itself.
The Anthropic provider record holds provider cost fields, listing base input at $3 and output at $15 per million tokens.
We compare each rate from the pinned record with Anthropic's published figure.
| Field checked | Pinned catalog record | Anthropic pricing page | Result |
|---|---|---|---|
| Base input | $3 per million tokens | $3 per million tokens | Match |
| Output | $15 per million tokens | $15 per million tokens | Match |
Anthropic lists both rates in its Sonnet 4.6 pricing row. If these two rates match, we also check the endpoint, region, tool support, and context limit. If a catalog field conflicts with a provider source, we keep both values visible until we can explain the difference from their versions and scope.
Route fields to fill in
With each provider's rules in view, we fill in the fields for the route we chose.
Route fields by provider.
Claude Sonnet 4.6 has a provider-hosted record (models-dev-provider-record) and a model-level record (models-dev-model-record) in models.dev.
Sources: Deploy and use Claude models in Microsoft Foundry - Microsoft Foundry | Microsoft Learn, Claude in Microsoft Foundry - Claude Platform Docs, API compatibility - Amazon Bedrock, APIs supported by Amazon Bedrock - Amazon Bedrock, OpenRouter API Reference - Complete Documentation, models dev source, models-dev-provider-record, models-dev-model-record.
| Provider | Endpoint and API | You still pick | Authentication | Tools and streaming | Docs |
|---|---|---|---|---|---|
| Foundry Claude | The resource-specific Anthropic path comes from the deployment's Target URI | Deployment name and version, hosting option, region scope | API key or Entra ID | Tool and streaming support varies by deployment | Foundry guide |
| Bedrock | A Runtime or Mantle endpoint, with APIs that vary by model | Endpoint, model, region | Bedrock API key or AWS credentials | Support follows the chosen model and endpoint | AWS APIs, model table |
| OpenRouter | Responses and Chat Completions paths | Model and upstream provider | An OpenRouter API key sent as a Bearer token | Normalized, but unsupported parameters may be ignored | API reference |
Once the fields are filled in, we test whether the route serves requests by sending one authorized, harmless request to the exact endpoint and API surface. We note five things and keep the credential itself out of the notes:
- the model or deployment ID
- the region
- which kind of credential we used
- what came back
- when we sent it
Written with curl from each provider's documentation, the same one-message request shows where each route names the model.
Amazon Bedrock
Converse on bedrock-runtime, from AWS's guide to using a Bedrock API key:
curl -X POST \
"https://bedrock-runtime.us-east-1.amazonaws.com\
/model/us.anthropic.claude-sonnet-4-6/converse" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AWS_BEARER_TOKEN_BEDROCK" \
-d '{
"messages": [
{"role": "user", "content": [{"text": "Hello"}]}
]
}'
Microsoft Foundry
Messages on a Claude deployment, from Anthropic's Foundry guide:
curl https://<resource-name>.services.ai.azure.com/anthropic/v1/messages \
-H "content-type: application/json" \
-H "api-key: $ANTHROPIC_FOUNDRY_API_KEY" \
-H "anthropic-version: 2026-10-21" \
-d '{
"model": "<deployment-name>",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello"}
]
}'
OpenRouter
Chat Completions, from OpenRouter's API reference:
curl https://openrouter.ai/api/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENROUTER_API_KEY" \
-d '{
"model": "anthropic/claude-sonnet-4.6",
"messages": [
{"role": "user", "content": "Hello"}
]
}'
Bedrock names the model in the URL path, while Foundry and OpenRouter name it in the model field of the body.
Foundry puts the resource name in the host and expects our deployment name in that field, and OpenRouter takes a model identifier on one shared host.
Each credential comes from an environment variable, sent as a Bearer token to Bedrock and OpenRouter and in an api-key header to Foundry.
The region and model identifiers in the Bedrock and OpenRouter panels are the documentation's own examples.
Prices can change
The models.dev links give us price snapshots at fixed revisions. We check current pricing and Foundry eligibility for the intended account and region because both can change.
Check the route before an agent relies on it
A catalog entry gives us metadata; the one authorized request against the exact endpoint and API surface tells us whether the route serves. A model server we run ourselves has no provider credential in front of it unless we add one, which Model servers are web apps covers.
What an attacker targets here
A hosted route puts a provider credential in front of the model, so an attacker targets that credential and any server we run without one.
- In our Ollama check, the official image listened on every interface and listing models answered HTTP 200 with no credential. We bind such a server to localhost or put authentication in front of it, as Model servers are web apps shows.
- A working key is query access, and MITRE ATLAS records adversaries using the responses of an inference API to replicate a model's behavior. Limiting query volume per key in a given period caps what they learn, as The gateway as an attack surface explains.
- A leaked key also spends money, the case OWASP calls denial of wallet. A budget on each gateway key caps it, which the same post covers.