# Currency Exchange Mcp (`vector384/currency-exchange-mcp`) Actor

Real-time currency exchange rates and crypto prices via MCP.
Convert 60+ fiat currencies and 30+ cryptocurrencies with multi-source failover. No API keys needed.

- **URL**: https://apify.com/vector384/currency-exchange-mcp.md
- **Developed by:** [Vector 384](https://apify.com/vector384) (community)
- **Categories:** Developer tools, MCP servers, E-commerce
- **Stats:** 7 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 currency conversions

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Currency Exchange & Crypto Rates MCP Server

A forex MCP server and currency exchange API for real-time exchange rates, cryptocurrency prices, and currency conversion. Convert between 60+ fiat currencies and 30+ cryptocurrencies — including bitcoin price lookups, batch forex conversions, and historical rate data. Multi-source failover across 5 providers with zero API keys required.

### Real-Time Currency Conversion & Exchange Rates

Connect this MCP server to any AI agent (Claude, GPT, custom agents) and give it the ability to:

- **Convert currencies** — "Convert 500 USD to EUR" or "How much is 1 bitcoin in rupees?"
- **Get exchange rates** — Current rates for any base currency against up to 50 targets
- **Look up historical rates** — Point-in-time rates or time-series data with change statistics
- **Batch convert** — Convert one amount to multiple currencies in a single call

Works with natural language input — say "dollars", "bitcoin", or "rupees" instead of memorizing currency codes.

### Why Choose This Currency Exchange API

| Feature | This Server | Typical Free APIs |
|---------|-------------|-------------------|
| Multi-source fallback | 5 providers, auto-failover | Single source, fails silently |
| Fiat + crypto | Both in one server | Usually separate services |
| API keys required | None | Most require signup |
| Natural language | "dollars", "bitcoin" | ISO codes only |
| Historical + time-series | Yes, with statistics | Usually current rates only |
| Caching | Smart tiered TTLs | None (hammers upstream) |
| Rate limiting | Built-in per-domain throttle | Your problem |

### Data Sources

Rates are sourced from multiple providers with automatic failover:

- **Fiat (current):** ExchangeRate-API (primary) → fawazahmed0 CDN (fallback)
- **Crypto (current):** Coinbase Public API (primary) → CoinGecko (fallback)
- **Historical:** Frankfurter/ECB (primary) → fawazahmed0 (fallback)

All upstream APIs are public and free. No API keys, no signup, no rate limit surprises.

### Supported Currencies

**Fiat (60+):** USD, EUR, GBP, JPY, AUD, CAD, CHF, CNY, INR, AED, SAR, KWD, SGD, HKD, KRW, BRL, MXN, ZAR, and many more covering Major, Gulf/Middle East, Asia-Pacific, Americas, Europe, and Africa regions.

**Crypto (30):** BTC, ETH, SOL, DOGE, ADA, DOT, AVAX, MATIC, LINK, UNI, XRP, LTC, BNB, USDT, USDC, SHIB, NEAR, APT, ARB, OP, and more.

### Tools

#### `convert_currency` — $0.003 per call
Convert an amount between any fiat or crypto pair.
```json
{ "amount": 100, "from": "USD", "to": "INR" }
{ "amount": 1, "from": "bitcoin", "to": "rupees" }
````

#### `batch_convert` — $0.008 per call

Convert one amount to multiple currencies at once. More cost-effective than multiple single conversions.

```json
{ "amount": 1000, "from": "USD", "to": ["EUR", "GBP", "INR", "JPY", "BTC"] }
```

#### `get_exchange_rates` — $0.003 per call

Get rates for a base currency against multiple targets (default: top 20 currencies).

```json
{ "base": "BTC", "targets": ["USD", "EUR", "INR", "GBP"] }
```

#### `get_historical_rate` — $0.008 per call

Historical rates for a single date or date range (max 365 days) with change statistics.

```json
{ "base": "USD", "target": "EUR", "startDate": "2025-01-01", "endDate": "2025-06-30" }
```

### Pricing

| Event | Price (USD) | Description |
|-------|-------------|-------------|
| Currency conversion | $0.003 | Single pair conversion |
| Batch conversion | $0.008 | Convert to up to 50 currencies at once |
| Exchange rates | $0.003 | Rates for base against multiple targets |
| Historical rate | $0.008 | Single date or time-series with statistics |

**Example monthly costs:**

- Light usage (100 conversions/month): ~$0.30
- Medium usage (1,000 conversions/month): ~$3.00
- Heavy usage (10,000 conversions/month): ~$30.00

### Supported Use Cases

- **Travel apps** — Show live exchange rates for destination currencies
- **Trading bots** — Get real-time crypto prices with fiat equivalents
- **Financial dashboards** — Historical trends with high/low/average statistics
- **E-commerce** — Display prices in customer's local currency
- **Accounting tools** — Historical rates for specific transaction dates
- **AI agents** — Give your agent real-time financial awareness

### Limitations (Honest)

- **Fiat rates update daily** (not real-time) — sourced from ExchangeRate-API
- **Crypto rates cached for 2 minutes** — to respect upstream API limits
- **No historical crypto rates** — Frankfurter and fawazahmed0 only cover fiat
- **Time-series limited to ECB currencies** (~33 pairs) via Frankfurter
- **Date ranges capped at 365 days**
- Precision: 6 decimal places (standard for display, not for high-frequency trading)

### Getting Started

1. **Deploy the Actor** — Push to Apify and enable [standby mode](https://docs.apify.com/platform/actors/development/programming-interface/standby).
2. **Get your endpoint** — Your MCP endpoint will be `https://<your-actor>.apify.actor/mcp`.
3. **Connect your AI agent** — Point any MCP-compatible client (Claude Desktop, Cursor, Cline, custom agents) at the endpoint.
4. **Add authentication** — Include your Apify API token in the `Authorization: Bearer` header.
5. **Start converting** — Call any of the 4 tools using natural language currency names or ISO codes.

```
POST https://<your-actor>.apify.actor/mcp
Authorization: Bearer YOUR_APIFY_API_TOKEN
Content-Type: application/json
```

The server uses the standard MCP JSON-RPC 2.0 protocol — compatible with any MCP client.

### Frequently Asked Questions

**What currencies does this exchange rate API support?**
Over 60 fiat currencies (USD, EUR, GBP, JPY, INR, AED, SAR, and more) plus 30 cryptocurrencies (BTC, ETH, SOL, DOGE, XRP, and more). See the full list in the Supported Currencies section above.

**Do I need an API key to get forex rates?**
No. All upstream data sources are public and free. You only need an Apify API token to authenticate with your deployed Actor — no third-party API keys required.

**How fresh are the exchange rates?**
Fiat rates update daily via ExchangeRate-API. Crypto rates (bitcoin, ethereum, etc.) are cached for 2 minutes via Coinbase and CoinGecko.

**Can I convert bitcoin to other cryptocurrencies?**
Yes. Crypto-to-crypto conversions (e.g., BTC to ETH) are handled automatically via a USD cross-rate.

**Does this currency converter API support historical rates?**
Yes. The `get_historical_rate` tool returns rates for a specific date or a date range (up to 365 days) with high, low, average, and percentage change statistics. Historical data covers ECB-supported fiat currencies.

**What happens if one data source goes down?**
The server automatically fails over to a backup provider. Fiat rates fall back from ExchangeRate-API to fawazahmed0, and crypto rates fall back from Coinbase to CoinGecko.

**Can I use natural language instead of currency codes?**
Yes. Say "dollars", "bitcoin", "rupees", or "yen" instead of USD, BTC, INR, or JPY. The smart currency resolver handles common names, abbreviations, and slang.

**Is there a free tier or trial?**
Pricing is pay-per-event with no monthly minimums. A single conversion costs $0.003 — try it with just a few calls to evaluate.

# Actor input Schema

## Actor input object example

```json
{}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("vector384/currency-exchange-mcp").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("vector384/currency-exchange-mcp").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 '{}' |
apify call vector384/currency-exchange-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Currency Exchange Mcp",
        "description": "Real-time currency exchange rates and crypto prices via MCP.\nConvert 60+ fiat currencies and 30+ cryptocurrencies with multi-source failover. No API keys needed.",
        "version": "1.0",
        "x-build-id": "9zpNIsinhuoa3hsJC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vector384~currency-exchange-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vector384-currency-exchange-mcp",
                "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/vector384~currency-exchange-mcp/runs": {
            "post": {
                "operationId": "runs-sync-vector384-currency-exchange-mcp",
                "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/vector384~currency-exchange-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-vector384-currency-exchange-mcp",
                "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": {}
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```