# Crypto & Fiat Exchange Rates Scraper (`parseforge/coincap-rates-scraper`) Actor

Export live exchange rates for ~75 crypto and fiat currencies (BTC, ETH, USD, EUR, GBP, JPY and more) from a free public market data source. Filter by a list of currency IDs or pull the full board in one run.

- **URL**: https://apify.com/parseforge/coincap-rates-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💱 Crypto & Fiat Exchange Rates Scraper

> 🚀 **Export the live global currency rate board in seconds.** Pull **150+ crypto, fiat, and commodity rates** all denominated against Bitcoin, in one clean dataset. No API key, no registration, no parser engineering.

> 🕒 **Last updated:** 2026-05-22 · **📊 8 fields** per record · **💱 150+ currencies** · **🌍 every major fiat & crypto** · **🔁 live per run**

The **Crypto & Fiat Exchange Rates Scraper** exports the global currency rate board and returns **150+ live rates**, including major fiat currencies (USD, EUR, GBP, JPY, CNY, INR), top crypto (BTC, ETH, BNB, XRP, SOL), and commodity reference units (gold, silver). Every rate is denominated in Bitcoin so you can re-derive any cross-pair in one division. Records arrive as CSV, Excel, JSON, or XML in under five seconds.

Coverage spans **the full fiat board, the top tradeable crypto tokens, and metal commodity references**, all from the same trusted global market data feed. Filter by category (crypto, fiat, commodity) or pass a specific list of currency IDs. All filters run on the source side, so you skip the parser engineering entirely.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Forex and crypto traders, accounting and finance tools, fintech apps, treasury teams, e-commerce platforms, indie devs | Daily rate snapshots, multi-currency pricing displays, treasury reporting, crypto-to-fiat conversion widgets, accounting reconciliation, dashboard tickers |

---

### 📋 What the Rates Scraper does

Three filtering workflows in a single run:

- 💵 **Full board.** Every supported currency and commodity in one pull.
- 🪙 **Crypto only.** Filter to crypto tokens (BTC, ETH, BNB, XRP, SOL, and more).
- 💷 **Fiat only.** Filter to fiat currencies across 150+ central banks.
- 🥇 **Commodity only.** Gold and silver reference rates.
- 🎯 **Specific IDs.** Pass an explicit list (e.g. `["btc", "eth", "usd", "eur"]`) and only those rates are returned.

Each record carries `id`, `name`, `unit`, `value` (denominated in 1 BTC), `type`, `base`, and a `scrapedAt` timestamp. Use the BTC base as a hub: divide any two rates to derive any cross-pair.

> 💡 **Why it matters:** accurate, fresh currency rates power treasury, payments, accounting, and trading workflows. Building your own pipeline means juggling multiple data providers, handling crypto and fiat separately, and refreshing constantly. This Actor returns one clean board on every run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded rates dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>rateType</code></td><td>string</td><td><code>"all"</code></td><td>One of: all, crypto, fiat, commodity.</td></tr>
<tr><td><code>currencyIds</code></td><td>array</td><td><code>[]</code></td><td>Optional list of currency IDs (e.g. btc, eth, usd, eur). When supplied, overrides rateType.</td></tr>
</tbody>
</table>

**Example: full board for treasury reporting.**

```json
{
    "maxItems": 200,
    "rateType": "all"
}
````

**Example: only USD, EUR, BTC, and ETH for a pricing widget.**

```json
{
    "maxItems": 4,
    "currencyIds": ["usd", "eur", "btc", "eth"]
}
```

> ⚠️ **Good to Know:** every value in the dataset is expressed as "how many of this currency equals 1 BTC". Need USD-to-EUR? Divide the USD rate by the EUR rate. For best accuracy, treat the feed as a reference snapshot, not a tradeable quote. For execution-grade pricing, layer in a live order book from your venue of choice.

***

### 📊 Output

Each rate record contains **8 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `id` | string | `"usd"` |
| 🏷️ `name` | string | `"US Dollar"` |
| 💱 `unit` | string | `"$"` |
| 💰 `value` | number | `77662.319` |
| 🏷️ `type` | string | `"fiat"` |
| 🪙 `base` | string | `"btc"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T00:00:00.000Z"` |
| ⚠️ `error` | string | null | `null` |

#### 📦 Sample records

<details>
<summary><strong>💵 US Dollar (fiat)</strong></summary>

```json
{
    "id": "usd",
    "name": "US Dollar",
    "unit": "$",
    "value": 77662.319,
    "type": "fiat",
    "base": "btc",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🇦🇪 UAE Dirham (fiat)</strong></summary>

```json
{
    "id": "aed",
    "name": "United Arab Emirates Dirham",
    "unit": "DH",
    "value": 285214.866,
    "type": "fiat",
    "base": "btc",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🥇 Gold (commodity)</strong></summary>

```json
{
    "id": "xau",
    "name": "Gold",
    "unit": "oz",
    "value": 23.74,
    "type": "commodity",
    "base": "btc",
    "scrapedAt": "2026-05-22T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 💱 | **One unified board.** Crypto, fiat, and commodities in a single dataset, all BTC-denominated. |
| 🎯 | **Targeted filters.** Pull all rates, only crypto, only fiat, only commodities, or just the IDs you need. |
| ⚡ | **Fast.** 10 rates in under 3 seconds, the full board in under 10 seconds. |
| 🌍 | **Broad coverage.** 150+ currencies across every major central bank and crypto venue. |
| 🪙 | **BTC base hub.** Derive any cross-pair with a single division. |
| 🚫 | **No authentication.** Works with public market data. No login or token needed. |
| 🔁 | **Always fresh.** Every run fetches the latest board, so the dataset reflects live market levels. |

> 📊 Accurate rate data is the foundation of every payments flow, treasury report, accounting reconciliation, and price display in modern fintech.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Rates Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **150+ crypto + fiat + metals** | **Live per run** | type, IDs | ⚡ 2 min |
| Bank / FX provider feeds | $$$$ enterprise | Fiat only | Streaming | Many | ⏳ Weeks |
| Crypto exchange tickers | Free per venue | Per-venue crypto | Streaming | Per-pair | 🐢 Days |
| Aggregator dashboards | $$$ | Mixed | Hourly | Limited | 🕒 Variable |

Pick this Actor when you want a one-call snapshot of the full global currency board, all in one schema.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Crypto & Fiat Exchange Rates Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a rate type (or leave as `all` for the full board) and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 💼 Treasury & Corporate Finance

- Daily multi-currency cash-position reporting
- FX exposure snapshots for treasury teams
- Cross-pair conversion for global subsidiaries
- Hedging benchmark rates for board decks

</td>
<td width="50%" valign="top">

#### 🛒 E-commerce & Multi-currency Pricing

- Real-time price localization at checkout
- Crypto checkout option with live conversion
- Daily price recalculation across product catalogs
- Currency-pair ticker in the storefront footer

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 Trading & Investment Apps

- Portfolio valuation across crypto and fiat
- Cross-pair derivation for charting tools
- Indicator inputs for swing-trade signals
- Watchlist tickers with live refresh

</td>
<td width="50%" valign="top">

#### 📚 Accounting & Compliance

- Day-end FX revaluation for ledgers
- Reconciliation between crypto wallets and bank statements
- Tax-period rate snapshots for capital gains calc
- Audit-trail-friendly rate archives

</td>
</tr>
</table>

***

### 🔌 Automating Rates Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Run every minute for live tickers, every hour for treasury feeds, or once at end-of-day for accounting snapshots.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Currency volatility and correlation studies
- Crypto-fiat dynamics for economics papers
- Reproducible rate datasets for finance courses
- FX shock event-study replication

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, indie wallet apps, portfolio demos
- Personal currency conversion utilities
- Crypto portfolio dashboards
- Travel budget calculators

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Cross-border donation conversion calculators
- Remittance fairness comparison sites
- Open finance data education resources
- Transparent treasury reports for non-profits

</td>
<td width="50%">

#### 🧪 Experimentation

- Train ML models on cross-currency dynamics
- Prototype FX arbitrage analyzers
- Test pricing strategies with live rates
- Build agent pipelines that monitor portfolios

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Crypto%20%26%20Fiat%20Exchange%20Rates%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Crypto%20%26%20Fiat%20Exchange%20Rates%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Crypto%20%26%20Fiat%20Exchange%20Rates%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Crypto%20%26%20Fiat%20Exchange%20Rates%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a rate type, optionally pass a list of currency IDs, click Start, and the Actor returns one clean record per currency. No browser automation, no captchas, no setup.

#### 💱 What's the base currency?

Every rate is denominated in Bitcoin. The `value` field tells you how many units of the currency equal 1 BTC. To get USD-to-EUR, divide `value` for USD by `value` for EUR.

#### 🪙 What currencies are supported?

150+ in total: the full major fiat board (USD, EUR, GBP, JPY, CNY, INR, BRL, AUD, CAD, CHF and 140+ more), top crypto tokens (BTC, ETH, BNB, XRP, SOL, DOT, ADA, DOGE, AVAX), and metal commodities (gold, silver).

#### 🔁 How fresh are the rates?

The source updates the board continuously. Every run pulls the latest snapshot, so the dataset reflects current market levels at the moment of the run.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to trigger this Actor on any cron interval. Common patterns: every minute for live tickers, every hour for treasury, or end-of-day for accounting snapshots.

#### 🎯 Can I get only specific currencies?

Yes. Pass `currencyIds` as an array (e.g. `["usd", "eur", "btc", "eth"]`) and the Actor returns only those rates. The filter is exact-match on the currency ID.

#### 🥇 Are commodities included?

Yes. Set `rateType: "commodity"` to get gold and silver reference rates (denominated in 1 BTC per ounce).

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger pulls.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### ⚖️ Is this data safe to use for production?

The rates are reference-grade and suitable for analytics, reporting, treasury, and indicative display. For execution-grade pricing (placing live orders), layer in a live order book from your venue of choice.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Rates Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get rate-move alerts in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe rates into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh rates into your pricing backend, or alert your team in Slack when a tracked rate crosses a threshold.

***

### 🔗 Recommended Actors

- [**📈 Indexmundi Scraper**](https://apify.com/parseforge/indexmundi-scraper) - Global demographic and economic indicators
- [**🏦 FINRA BrokerCheck Scraper**](https://apify.com/parseforge/finra-brokercheck-scraper) - U.S. broker and advisor registration records
- [**🤗 Hugging Face Model Scraper**](https://apify.com/parseforge/hugging-face-model-scraper) - Discover ML models for finance and trading
- [**📰 PR Newswire Scraper**](https://apify.com/parseforge/pr-newswire-scraper) - Press releases for market-moving news
- [**✈️ OurAirports Global Airport Database Scraper**](https://apify.com/parseforge/ourairports-scraper) - Worldwide airport reference data

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by any cryptocurrency exchange, central bank, or rate provider. All trademarks mentioned are the property of their respective owners. Only publicly available open market reference data is collected. Rates are indicative and not intended as financial advice or as a substitute for execution-grade venue quotes.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `rateType` (type: `string`):

Filter to a single currency category: all, crypto, fiat, or commodity (gold/silver).

## `currencyIds` (type: `array`):

Optional list of currency IDs to filter (e.g. btc, eth, usd, eur). When supplied, overrides Currency Type. Leave empty to pull all rates of the chosen type.

## Actor input object example

```json
{
  "maxItems": 10,
  "rateType": "all"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "maxItems": 10,
    "rateType": "all"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/coincap-rates-scraper").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 = {
    "maxItems": 10,
    "rateType": "all",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/coincap-rates-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "rateType": "all"
}' |
apify call parseforge/coincap-rates-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/coincap-rates-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crypto & Fiat Exchange Rates Scraper",
        "description": "Export live exchange rates for ~75 crypto and fiat currencies (BTC, ETH, USD, EUR, GBP, JPY and more) from a free public market data source. Filter by a list of currency IDs or pull the full board in one run.",
        "version": "1.0",
        "x-build-id": "F0puAXxbqfGYrxGoD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~coincap-rates-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-coincap-rates-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~coincap-rates-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-coincap-rates-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~coincap-rates-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-coincap-rates-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "rateType": {
                        "title": "Currency Type",
                        "enum": [
                            "all",
                            "crypto",
                            "fiat",
                            "commodity"
                        ],
                        "type": "string",
                        "description": "Filter to a single currency category: all, crypto, fiat, or commodity (gold/silver)."
                    },
                    "currencyIds": {
                        "title": "Currency IDs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional list of currency IDs to filter (e.g. btc, eth, usd, eur). When supplied, overrides Currency Type. Leave empty to pull all rates of the chosen type.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
