How to Use Exchange Rate APIs with AI Agents, LLMs, and Chatbots

AI assistants are increasingly expected to answer questions about money: "How much is $500 in euros?", "What is the current GBP/JPY rate?", "Convert my invoice from CAD to USD." But large language models do not have access to live data. Their training data is frozen at a cutoff date, and exchange rates change every minute.

To give an AI agent accurate, real-time financial data, you need to connect it to a live exchange rate API. This article covers three practical approaches — MCP servers, function calling (tool use), and direct API integration — with working code examples using AllRatesToday.

Why AI Agents Need Live Exchange Rates

LLMs like Claude, GPT-4, and Gemini are trained on static datasets. When a user asks "What is the USD to EUR rate?", the model can only guess based on whatever rates appeared in its training data — which could be months or years out of date.

This is a problem for any application where accuracy matters:

• Customer support bots that quote prices in a visitor's local currency
• Financial analysis agents that need current or historical exchange rates for reporting
• Travel planning assistants that calculate trip budgets across currencies
• E-commerce chatbots that display product prices in multiple currencies
• Internal tools that reconcile invoices denominated in foreign currencies

The solution is to give the AI agent a tool it can call to fetch live rates from a reliable source. AllRatesToday provides real-time mid-market rates for 160+ currencies, updated every 60 seconds from Reuters/Refinitiv and interbank feeds.

Approach 1: MCP Servers

The Model Context Protocol (MCP) is an open standard that lets AI assistants discover and call external tools. Instead of writing custom glue code, you configure an MCP server and the AI assistant automatically gains access to its tools.

AllRatesToday provides an official MCP server: @allratestoday/mcp-server. It exposes exchange rate tools that Claude, Cursor, Windsurf, and other MCP-compatible clients can call directly.

Install the MCP server

npm install -g @allratestoday/mcp-server

Configure for Claude Code

Add the following to your Claude Code MCP configuration:

{
  "mcpServers": {
    "allratestoday": {
      "command": "npx",
      "args": ["-y", "@allratestoday/mcp-server"],
      "env": {
        "ALLRATESTODAY_API_KEY": "art_live_..."
      }
    }
  }
}

Configure for Cursor

In Cursor, open Settings and navigate to the MCP section. Add the server:

{
  "mcpServers": {
    "allratestoday": {
      "command": "npx",
      "args": ["-y", "@allratestoday/mcp-server"],
      "env": {
        "ALLRATESTODAY_API_KEY": "art_live_..."
      }
    }
  }
}

Available MCP tools

The AllRatesToday MCP server exposes the following tools:

Approach 2: Function Calling (Tool Use)

If you are building with the OpenAI or Anthropic API directly, you can define exchange rate tools using function calling. The LLM decides when to call the tool, your code executes the API call, and the result is fed back into the conversation.

OpenAI function calling example

import openai
from allratestoday import AllRatesToday

art = AllRatesToday("art_live_...")
client = openai.OpenAI()

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_exchange_rate",
            "description": "Get the current exchange rate between two currencies. Use this whenever a user asks about currency conversion or exchange rates.",
            "parameters": {
                "type": "object",
                "properties": {
                    "source": {
                        "type": "string",
                        "description": "The source currency code (e.g. USD, EUR, GBP)"
                    },
                    "target": {
                        "type": "string",
                        "description": "The target currency code (e.g. EUR, JPY, CAD)"
                    }
                },
                "required": ["source", "target"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "convert_currency",
            "description": "Convert a specific amount from one currency to another using live exchange rates.",
            "parameters": {
                "type": "object",
                "properties": {
                    "source": {
                        "type": "string",
                        "description": "The source currency code"
                    },
                    "target": {
                        "type": "string",
                        "description": "The target currency code"
                    },
                    "amount": {
                        "type": "number",
                        "description": "The amount to convert"
                    }
                },
                "required": ["source", "target", "amount"]
            }
        }
    }
]

def handle_tool_call(tool_call):
    import json
    args = json.loads(tool_call.function.arguments)
    if tool_call.function.name == "get_exchange_rate":
        rate = art.get_rate(args["source"], args["target"])
        return json.dumps({"source": args["source"], "target": args["target"], "rate": rate})
    elif tool_call.function.name == "convert_currency":
        result = art.convert(args["source"], args["target"], args["amount"])
        return json.dumps(result)

# Send a message with tools
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "How much is 1000 USD in Japanese yen?"}],
    tools=tools,
)

# Process tool calls
if response.choices[0].message.tool_calls:
    tool_call = response.choices[0].message.tool_calls[0]
    result = handle_tool_call(tool_call)
    print(result)

Anthropic tool use example

import anthropic
from allratestoday import AllRatesToday

art = AllRatesToday("art_live_...")
client = anthropic.Anthropic()

tools = [
    {
        "name": "get_exchange_rate",
        "description": "Get the current exchange rate between two currencies. Use this whenever a user asks about currency conversion or exchange rates.",
        "input_schema": {
            "type": "object",
            "properties": {
                "source": {
                    "type": "string",
                    "description": "The source currency code (e.g. USD, EUR, GBP)"
                },
                "target": {
                    "type": "string",
                    "description": "The target currency code (e.g. EUR, JPY, CAD)"
                }
            },
            "required": ["source", "target"]
        }
    },
    {
        "name": "convert_currency",
        "description": "Convert a specific amount from one currency to another using live exchange rates.",
        "input_schema": {
            "type": "object",
            "properties": {
                "source": {
                    "type": "string",
                    "description": "The source currency code"
                },
                "target": {
                    "type": "string",
                    "description": "The target currency code"
                },
                "amount": {
                    "type": "number",
                    "description": "The amount to convert"
                }
            },
            "required": ["source", "target", "amount"]
        }
    }
]

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Convert 2500 EUR to USD"}],
    tools=tools,
)

# Process tool use blocks
for block in response.content:
    if block.type == "tool_use":
        if block.name == "get_exchange_rate":
            rate = art.get_rate(block.input["source"], block.input["target"])
            print(f"Rate: {rate}")
        elif block.name == "convert_currency":
            result = art.convert(
                block.input["source"],
                block.input["target"],
                block.input["amount"]
            )
            print(f"Result: {result}")

Approach 3: Direct API Calls for Custom Chatbots

If you are building a custom chatbot without a function-calling framework, you can call the AllRatesToday API directly in your application logic. This works well for rule-based bots, Slack/Discord integrations, or any backend service that needs exchange rate data.

JavaScript (Node.js)

import AllRatesToday from '@allratestoday/sdk';

const client = new AllRatesToday('art_live_...');

// In your chatbot message handler
async function handleCurrencyQuery(source, target, amount) {
  if (amount) {
    const result = await client.convert(source, target, amount);
    return `${amount} ${source} = ${result.result} ${target} (rate: ${result.rate})`;
  }

  const rate = await client.getRate(source, target);
  return `1 ${source} = ${rate} ${target}`;
}

// Example usage
const reply = await handleCurrencyQuery('USD', 'EUR', 1000);
console.log(reply);
// Output: 1000 USD = 923.40 EUR (rate: 0.9234)

Python

from allratestoday import AllRatesToday

client = AllRatesToday("art_live_...")

def handle_currency_query(source, target, amount=None):
    if amount:
        result = client.convert(source, target, amount)
        return f"{amount} {source} = {result['result']} {target} (rate: {result['rate']})"

    rate = client.get_rate(source, target)
    return f"1 {source} = {rate} {target}"

# Example usage
reply = handle_currency_query("GBP", "JPY", 500)
print(reply)
# Output: 500 GBP = 95250.00 JPY (rate: 190.50)

Raw API call

curl -X GET "https://allratestoday.com/api/v1/rates?source=USD&target=EUR" \
  -H "Authorization: Bearer art_live_..."

{
  "source": "USD",
  "target": "EUR",
  "rate": 0.9234,
  "time": "2026-05-25T12:00:00Z"
}

Use Cases

Customer support bots

An e-commerce support bot can automatically convert prices to a customer's local currency. When a user asks "How much does the Pro plan cost in BRL?", the bot fetches the live USD/BRL rate from AllRatesToday and responds with an accurate, up-to-the-minute conversion.

Financial analysis agents

AI-powered financial tools can pull historical and real-time exchange rates for portfolio analysis, FX exposure reports, and multi-currency reconciliation. The AllRatesToday API provides both current rates and historical data for trend analysis.

Travel planning assistants

A travel chatbot can calculate trip budgets across multiple currencies. "I have $3,000 for two weeks in Japan and Thailand" requires live USD/JPY and USD/THB rates to give a meaningful answer.

E-commerce price localization

AI agents embedded in e-commerce platforms can dynamically display prices in a visitor's currency. Combined with AllRatesToday's real-time rates, this ensures prices reflect current market conditions rather than stale daily snapshots.

Best Practices

• Cache exchange rates: Exchange rates do not change every second. Cache rates for 60 seconds to reduce API calls without sacrificing accuracy. AllRatesToday updates rates every 60 seconds, so more frequent polling provides no benefit.
• Respect rate limits: Design your agent to handle rate limit responses gracefully. Use exponential backoff and cache aggressively. For high-traffic bots, consider a background worker that refreshes rates on a schedule.
• Write precise tool descriptions: The quality of your tool descriptions directly affects how well the LLM decides when to call them. Include the purpose, expected inputs, and when the tool should be used.
• Validate currency codes: Before calling the API, validate that the currency codes are real ISO 4217 codes. This prevents wasted API calls and confusing error messages for users.
• Handle errors in tool responses: If the API returns an error (invalid currency, rate limit exceeded), return a clear error message to the LLM so it can inform the user rather than hallucinating a rate.
• Use mid-market rates transparently: AllRatesToday provides mid-market rates from Reuters/Refinitiv. If your application involves actual money transfers, make clear that the final rate may differ from the mid-market rate shown.

Integration Comparison

Quick Reference

• MCP Server: npm install -g @allratestoday/mcp-server
• JavaScript SDK: npm install @allratestoday/sdk
• Python SDK: pip install allratestoday
• API Endpoint: GET /api/v1/rates?source=USD&target=EUR
• Auth: Authorization: Bearer art_live_...
• GitHub: allratestoday/exchange-rates-api