# Cloud AI Model Finder: Bedrock vs Azure vs Vertex Prices (`cobalt_relay/cloud-ai-model-finder`) Actor

Find which AI models (Claude, GPT, Gemini, Llama and more) you can run in your region on AWS Bedrock, Azure AI Foundry and Google Vertex AI, with token prices and whether your data stays in-country.

- **URL**: https://apify.com/cobalt_relay/cloud-ai-model-finder.md
- **Developed by:** [Cobalt Relay](https://apify.com/cobalt_relay) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 model searches

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Cloud AI Model Finder: Bedrock vs Azure vs Vertex Prices

**Which AI models can you run in your region, what do they cost per token, and does your data stay in-country?**

This Actor searches official, daily-refreshed token prices from **AWS Bedrock**, **Azure AI Foundry** and **Google Vertex AI**, covering Claude, GPT, Gemini, Llama, Mistral, DeepSeek, Qwen, Grok, Kimi and hundreds more, and shows every cloud and region where a model is sold, cheapest first.

### What you get

Search `claude sonnet 4.5` and `gpt 5` for **Canada**, keeping data **within the geography**:

| Search | Model | Cloud | Region | Data processed | Input $/1M | Output $/1M |
|---|---|---|---|---|---|---|
| claude sonnet 4.5 | Claude Sonnet 4.5 | AWS | ca-central-1 | regional | 3.30 | 16.50 |
| gpt 5 | — | — | — | — | *No option matches: offered in Canada only with global processing* | |

Switch residency to **Anywhere** and GPT-5 appears in Azure's Canadian regions with **global** processing, where prompts may be handled outside Canada. That's the kind of detail that's hard to find in price lists and matters for privacy reviews.

### Why use it

- **Data residency built in.** Every price is tagged with *where your prompts are processed*: in the region, within a geography (AWS geography inference, Azure Data Zone, Vertex `us`/`eu`), or globally. Filter to what your policy allows.
- **Three clouds, one search.** No more digging through three pricing pages that name models differently.
- **The real cost of residency.** In-region processing is often about 10% more than global. You see both and decide.
- **Monthly estimates.** Enter your monthly input and output tokens to rank options by total cost.
- **Clear "no" answers.** If a model isn't available under your constraints, you get an explicit row saying so, not an empty table.

### Who it's for

- Architects and platform teams choosing where to deploy LLM workloads
- Privacy, security and compliance teams reviewing AI data flows (PIPEDA, Quebec Law 25, GDPR, sector rules)
- FinOps teams comparing AI spend across clouds
- AI agents answering "where can I run model X, and for how much?" (callable through the Apify MCP server)

### How to use it

1. **Models to find:** one per line, partial names work: `claude sonnet 4.5`, `gpt 5`, `gemini 2.5 flash`, `llama 4`, `deepseek`. A search like `gpt 5` also finds `GPT-5 mini`, `GPT-5.4` and so on.
2. **Location:** Canada, United States, European Union, United Kingdom, Anywhere, or Custom regions (any region codes, e.g. `ca-central-1`, `swedencentral`).
3. **Where may your prompts be processed?**
   - *In the region only*
   - *Within the geography* (default)
   - *Anywhere*, which includes cheaper global processing
4. Optionally enter **monthly tokens** for a cost estimate, include **batch** prices, or limit to specific **clouds**.

### Output

| Field | Meaning |
|---|---|
| `search` | Your search term |
| `model`, `provider` | Model name as the cloud lists it, and its maker |
| `cloud`, `region` | `aws` / `azure` / `gcp`, and the region(s). Regions with identical prices share one row (first 6 shown, then "+N more") (GCP: `us`, `eu`, `global` or `regional`) |
| `regions`, `regionCount` | The full list of regions, and how many |
| `dataProcessing` | `regional`, `geo`, `global` or `unspecified` |
| `dataProcessingDetail` | Plain-language explanation for that cloud |
| `tier` | `standard`, or `batch` if requested |
| `inputPer1M`, `outputPer1M`, `cachedInputPer1M` | USD per million tokens |
| `monthlyCostUsd` | Estimate from your monthly tokens, if given |
| `vsCheapestPct`, `isCheapest` | How this option compares with the cheapest place to run the same model |
| `noMatch`, `note` | Set when nothing matches your constraints |
| `pricesUpdatedAt` | When prices were last refreshed |

### Pricing

**$0.02 per model search** that returns results. "No match" answers are free.

### How each cloud describes data processing

| Cloud | What the price list tells us |
|---|---|
| **AWS Bedrock** | Two prices per model and region: **Global** (cheaper; any AWS region) and **in-region/in-geography**. AWS charges the same for single-region and geography-limited inference, so they share one label. |
| **Azure AI Foundry** | Per region: **Regional**, **Data Zone** (US or EU) and **Global** deployments, where offered. |
| **Google Vertex AI** | Claude: `us`, `eu` or `global`. Gemini: one **Regional** price that applies to whichever region you deploy to, and a **Global** price. Google doesn't list which regions offer each model, so confirm availability in your chosen region. |

### Coverage and limits

- **Text tokens, on-demand** (plus batch if selected). Image, audio and video tokens, fine-tuning, provisioned throughput and long-context surcharges are not included yet.
- **List prices in USD** from each cloud's public price list. Enterprise discounts and commitments are not reflected.
- **Google Vertex:** only the Claude versions present in Google's public billing catalog are covered, currently the newest ones. Older Claude versions on Vertex are billed in a way the public catalog doesn't show.
- **Azure** model names are abbreviated in Microsoft's price list. They're cleaned up automatically, and a few may read slightly differently from the model catalog.

### FAQ

**Why is the same model cheaper with global processing?**
Clouds discount global routing because they can serve your request wherever capacity is free. In-region and in-geography processing usually cost about 10% more.

**Does "regional" mean my data never leaves the country?**
It means the cloud processes the request in that region. Logging, abuse monitoring and support access are governed by each provider's terms, so review those for compliance decisions. This Actor tells you what is priced and offered, not what is legally sufficient.

**How fresh is the data?**
Prices are refreshed daily from the providers' official price feeds. See `pricesUpdatedAt`.

### Feedback

Missing a model or region you need? Open an issue on the **Issues** tab.

# Actor input Schema

## `models` (type: `array`):

One search per line. Partial names work: 'claude sonnet 4.5', 'gpt 5', 'gemini 2.5 flash', 'llama 4', 'deepseek'.

## `location` (type: `string`):

Where you need to run the model. Choose Custom to list exact regions.

## `customRegions` (type: `array`):

Used when Location is Custom. Region codes from any cloud, e.g. ca-central-1, canadacentral, eu-west-1, swedencentral, us, eu.

## `residency` (type: `string`):

In region: only in the region itself. In geography: within the same country or zone (AWS geography inference, Azure Data Zone, Vertex us/eu). Anywhere: also includes cheaper global processing.

## `clouds` (type: `array`):

Which clouds to include.

## `monthlyInputTokensMillions` (type: `integer`):

Optional. With output tokens, estimates each option's monthly cost and ranks by it.

## `monthlyOutputTokensMillions` (type: `integer`):

Optional.

## `includeBatch` (type: `boolean`):

Also list discounted batch (asynchronous) prices.

## `maxResultsPerModel` (type: `integer`):

Cheapest options first, for each matching model. A broad search like 'claude' lists every matching model.

## Actor input object example

```json
{
  "models": [
    "claude sonnet 4.5",
    "gpt 5"
  ],
  "location": "canada",
  "residency": "in-geography",
  "clouds": [
    "aws",
    "azure",
    "gcp"
  ],
  "includeBatch": false,
  "maxResultsPerModel": 20
}
```

# Actor output Schema

## `options` (type: `string`):

Every matching AI model on AWS Bedrock, Azure AI Foundry and Google Vertex AI for your location and data-residency choice, with token prices, cheapest first.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "models": [
        "claude sonnet 4.5",
        "gpt 5"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cobalt_relay/cloud-ai-model-finder").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "models": [
        "claude sonnet 4.5",
        "gpt 5",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("cobalt_relay/cloud-ai-model-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "models": [
    "claude sonnet 4.5",
    "gpt 5"
  ]
}' |
apify call cobalt_relay/cloud-ai-model-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cobalt_relay/cloud-ai-model-finder"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/JGn96jBoQTBJ68UZA/builds/XgG4Vuz5WJN4PqXcc/openapi.json