Currency API Documentation

Free, real-time currency exchange rates and conversion API. Integrate currency conversion into your applications with our comprehensive REST API.

Real-time rates
Free forever
Historical data

Try It Live!

Test the API with our interactive currency converter

Live Convert

Quick Start

Get started with FastTools Currency API in seconds. No API key required for basic usage.

GET
https://www.fasttools.store/api/currency_converter/latest?base=USD&api_key=YOUR_API_KEY

Response:

{
  "success": true,
  "data": {
    "base": "USD",
    "date": "2024-01-15",
    "rates": {
      "EUR": 0.92,
      "GBP": 0.79,
      "JPY": 149.5,
      "CAD": 1.36
    }
  },
  "timestamp": "2024-01-15T10:30:00Z"
}

Get Your Free API Key

Get a free API key to enhance your FastTools Currency API experience. No registration required - just click the button below!

Ready to Get Started?

Get your free API key instantly

How to Use Your API Key

Once you have your API key, here's how to use it with FastTools Currency API.

1

Copy Your API Key

After clicking "Get My Key", you'll receive a response with your unique API key:

"apiKey": "K8mN2pQ7vR9sfssT4uW6xY1zA3bC5dE8fG"
2

Use Your Key in API Calls

Add your key to API requests using either method:

Header Method:
X-API-Key: K8mN2pQ7vfsfsR9sT4uW6xY1zA3bC5dE8fG
Query Parameter Method:
?api_key=K8mN2pQ7vR9sT4uW6xY1zA3bC5dE8fGfsfs
3

Test Your Integration

Try making a currency conversion with your new key:

GET https://www.fasttools.store/api/currency_converter/latest?api_key=K8mN2pQ7vR9sT4usdW6xY1zA3bC5dE8fG

✅ You're All Set!

Your API key is now ready to use with all FastTools Currency API endpoints. Keep it secure and enjoy unlimited access to our currency data!

API Endpoints

GET

Get Available Currencies

Retrieve a list of all supported currencies with their codes, names, and symbols.

GET
https://www.fasttools.store/api/currency_converter/currencies?api_key=YOUR_API_KEY

Response:

{
  "success": true,
  "data": [
    {
      "code": "USD",
      "name": "US Dollar",
      "symbol": "$"
    },
    {
      "code": "EUR", 
      "name": "Euro",
      "symbol": "€"
    }
  ],
  "count": 100
}
GET

Get Latest Exchange Rates

Get the latest exchange rates for a base currency. Optionally filter by specific target currencies.

GET
https://www.fasttools.store/api/currency_converter/latest?base=USD&symbols=EUR,GBP,JPY&api_key=YOUR_API_KEY

Parameters:

baseBase currency code (default: EUR)
symbolsComma-separated target currencies (optional)

Response:

{
  "success": true,
  "data": {
    "base": "USD",
    "date": "2024-01-15",
    "rates": {
      "EUR": 0.92,
      "GBP": 0.79,
      "JPY": 149.5
    }
  },
  "timestamp": "2024-01-15T10:30:00Z"
}
POST

Convert Currency

Convert an amount from one currency to another using real-time exchange rates.

POST
https://www.fasttools.store/api/currency_converter/convert?api_key=YOUR_API_KEY

Request Body:

{
  "from": "USD",
  "to": "EUR", 
  "amount": 100
}

Response:

{
  "success": true,
  "data": {
    "from": "USD",
    "to": "EUR",
    "amount": 100,
    "convertedAmount": 92.00,
    "rate": 0.9200,
    "date": "2024-01-15"
  },
  "timestamp": "2024-01-15T10:30:00Z"
}
GET

Get Historical Rates (by Date)

Retrieve exchange rates for a specific historical date.

GET
https://www.fasttools.store/api/currency_converter/historical?date=2024-01-15&base=USD&symbols=EUR,GBP&api_key=YOUR_API_KEY

Parameters:

dateRequired. Date in YYYY-MM-DD format
baseBase currency code (default: EUR)
symbolsComma-separated target currencies (optional)
GET

Get Time Series Rates

Fetch exchange rates over a date range (up to 365 days).

GET
https://www.fasttools.store/api/currency_converter/timeseries?start_date=2024-01-01&end_date=2024-01-10&base=USD&symbols=EUR,GBP&api_key=YOUR_API_KEY

Parameters:

start_dateRequired. Start date in YYYY-MM-DD format
end_dateRequired. End date in YYYY-MM-DD format
baseBase currency code (default: EUR)
symbolsComma-separated target currencies (optional)
GET

Get Top 10 Currencies (last N days)

Return processed stats for the top 10 traded currencies over a recent period.

GET
https://www.fasttools.store/api/currency_converter/top10?base=USD&days=10&api_key=YOUR_API_KEY

Parameters:

baseBase currency code used for comparison (default: USD)
daysNumber of past days to analyze (default: 10)

Usage Examples

JavaScript

// Get latest rates
const response = await fetch(
  'https://www.fasttools.store/api/currency_converter/latest?base=USD&api_key=YOUR_API_KEY'
);
const data = await response.json();
console.log(data.data.rates);

// Convert currency
const convertResponse = await fetch(
  'https://www.fasttools.store/api/currency_converter/convert?api_key=YOUR_API_KEY',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      from: 'USD',
      to: 'EUR',
      amount: 100
    })
  }
);
const convertData = await convertResponse.json();
console.log(convertData.data.convertedAmount);

Python

import requests

# Get latest rates
response = requests.get(
    'https://www.fasttools.store/api/currency_converter/latest?base=USD&api_key=YOUR_API_KEY'
)
data = response.json()
print(data['data']['rates'])

# Convert currency
convert_response = requests.post(
    'https://www.fasttools.store/api/currency_converter/convert?api_key=YOUR_API_KEY',
    json={
        'from': 'USD',
        'to': 'EUR',
        'amount': 100
    }
)
convert_data = convert_response.json()
print(convert_data['data']['convertedAmount'])

PHP

<?php
// Get latest rates
$response = file_get_contents(
    'https://www.fasttools.store/api/currency_converter/latest?base=USD'
);
$data = json_decode($response, true);
echo $data['data']['rates']['EUR'];

// Convert currency
$postData = json_encode([
    'from' => 'USD',
    'to' => 'EUR',
    'amount' => 100
]);

$context = stream_context_create([
    'http' => [
        'method' => 'POST',
        'header' => 'Content-Type: application/json',
        'content' => $postData
    ]
]);

$response = file_get_contents(
    'https://www.fasttools.store/api/currency_converter/convert',
    false,
    $context
);
$data = json_decode($response, true);
echo $data['data']['convertedAmount'];
?>

cURL

# Get latest rates
curl "https://www.fasttools.store/api/currency_converter/latest?base=USD&api_key=YOUR_API_KEY"

# Convert currency
curl -X POST "https://www.fasttools.store/api/currency_converter/convert?api_key=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "USD",
    "to": "EUR", 
    "amount": 100
  }'

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    // Get latest rates
    resp, err := http.Get("https://www.fasttools.store/api/currency_converter/latest?base=USD&api_key=YOUR_API_KEY")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }
    
    var result map[string]interface{}
    json.Unmarshal(body, &result)
    fmt.Println(result["data"])
    
    // Convert currency
    data := map[string]interface{}{
        "from":   "USD",
        "to":     "EUR",
        "amount": 100,
    }
    
    jsonData, _ := json.Marshal(data)
    resp, err = http.Post(
        "https://www.fasttools.store/api/currency_converter/convert?api_key=YOUR_API_KEY",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, err = io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }
    
    json.Unmarshal(body, &result)
    fmt.Println(result["data"])
}

Java

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.io.IOException;

public class CurrencyAPI {
    public static void main(String[] args) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newHttpClient();
        
        // Get latest rates
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://www.fasttools.store/api/currency_converter/latest?base=USD&api_key=YOUR_API_KEY"))
            .build();
            
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
        
        // Convert currency
        String jsonBody = "{\"from\":\"USD\",\"to\":\"EUR\",\"amount\":100}";
        HttpRequest convertRequest = HttpRequest.newBuilder()
            .uri(URI.create("https://www.fasttools.store/api/currency_converter/convert?api_key=YOUR_API_KEY"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();
            
        HttpResponse<String> convertResponse = client.send(convertRequest, HttpResponse.BodyHandlers.ofString());
        System.out.println(convertResponse.body());
    }
}

Rate Limits & Policies

Rate Limits

  • • Free Tier: 1,000 requests per day
  • • Rate Limit: 100 requests per minute
  • • Burst Limit: 10 requests per second
  • • No API Key Required: Start using immediately

Usage Policies

  • • Commercial Use: Allowed with attribution
  • • Attribution: Powered by FastTools.store
  • • Data Accuracy: Best effort, not guaranteed
  • • Support: Community-driven support

Currency API FAQ - Everything You Need to Know

1. How accurate are FastTools currency exchange rates?

FastTools.store provides highly accurate, real-time exchange rates that are updated throughout the day to reflect current market conditions. Our currency API is trusted by thousands of developers worldwide.

The rates shown represent mid-market rates (the average between buy and sell rates). When you actually exchange currency through banks or exchange services, you'll typically pay slightly different rates due to:

  • Service fees: Banks and exchange services charge fees for currency conversion
  • Spread margins: The difference between buy and sell rates
  • Processing fees: Additional charges for international transactions

FastTools.store provides free, accurate currency conversion to help you make informed decisions. For the most accurate real-world conversion estimates, consider adding 1-3% to account for typical service fees.

2. How often does FastTools update exchange rates?

FastTools.store updates exchange rates in real-time during market hours to ensure you always have the most current information:

  • Active trading hours: Rates update every few minutes for maximum accuracy
  • Weekend/holidays: Rates may update less frequently or use last known rates
  • Major currencies: USD, EUR, GBP, JPY update more frequently than exotic currencies
  • Market volatility: During high volatility, FastTools updates rates more frequently

The timestamp shown in our API responses indicates when the rates were last updated. FastTools.store ensures you have access to the most current exchange rates available.

Our historical rates feature helps you research past trends, but current market conditions may differ significantly from past rates.

3. Do I need an API key to use FastTools Currency API?

No API key is required for basic usage! FastTools.store offers a generous free tier that allows you to start using our currency API immediately:

  • Free Tier: 1,000 requests per day without any API key
  • Rate Limits: 100 requests per minute, 10 requests per second
  • All Endpoints: Access to all currency conversion endpoints
  • No Registration: Start using the API immediately

However, you can get a free API key for enhanced access:

  • Instant Generation: Click "Get My Key" button or call /api/currency_converter/api-key
  • Unique Keys: Each key is unique and secure
  • No Registration: No signup or approval process required
  • Persistent Keys: Keys never expire and work forever
  • Regenerate Anytime: Get a new key whenever you want

API keys are optional but recommended for production applications to ensure consistent access and better rate limits.

4. What currencies are supported by FastTools Currency API?

FastTools.store supports over 100 currencies from around the world, including all major and many minor currencies:

  • Major Currencies: USD, EUR, GBP, JPY, CHF, CAD, AUD, NZD
  • Emerging Markets: CNY, INR, BRL, MXN, ZAR, KRW, SGD
  • Middle East: AED, SAR, QAR, KWD, BHD, OMR, JOD
  • European: SEK, NOK, DKK, PLN, CZK, HUF, RON
  • Asian: THB, MYR, IDR, PHP, VND, TWD, HKD

You can get the complete list of supported currencies using our /api/currency_converter/currencies endpoint.

If you need a currency that's not currently supported, please contact us and we'll consider adding it to our API.

5. How do I handle API errors and rate limits?

FastTools Currency API provides comprehensive error handling and rate limit information:

  • Error Responses: All errors include success: false, error type, and descriptive message
  • Rate Limit Headers: X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset
  • HTTP Status Codes: 200 (success), 400 (bad request), 429 (rate limit), 500 (server error)
  • Retry After: Retry-After header indicates when you can make another request

Best practices for handling errors:

  • Check success field: Always verify the success field in responses
  • Implement retry logic: Use exponential backoff for rate limit errors
  • Handle network errors: Implement proper timeout and retry mechanisms
  • Log errors: Keep logs for debugging and monitoring

Remember that FastTools.store provides mid-market rates for reference. Always verify actual rates and fees with your chosen service provider before making transactions.

6. Is FastTools Currency API really free? What are the limitations?

Yes, FastTools.store offers a completely free currency API with generous limits designed for developers and businesses of all sizes:

  • No Cost: Absolutely free to use with no hidden fees or charges
  • No Credit Card Required: Start using immediately without providing payment information
  • Generous Limits: 1,000 requests per day, 100 per minute, 10 per second
  • All Features: Access to all endpoints including historical data and time series
  • Commercial Use: Free for both personal and commercial applications

Unlike many competitors who charge per request or require expensive subscriptions, FastTools.store believes in providing free access to essential currency data. Our free tier is designed to support:

  • Small to Medium Apps: Perfect for startups and growing businesses
  • Personal Projects: Ideal for developers learning and experimenting
  • Educational Use: Great for students and academic projects
  • Prototype Development: Test your ideas without upfront costs

If you need higher limits for enterprise applications, contact us to discuss custom solutions that maintain our commitment to affordable access.

7. How do I get started with FastTools Currency API quickly?

Getting started with FastTools Currency API is incredibly simple and takes just minutes:

  • No Registration: Start making API calls immediately without signing up
  • Simple Endpoints: Clean, RESTful API design that's easy to understand
  • JSON Responses: All responses in standard JSON format
  • Clear Documentation: Comprehensive guides and examples
  • Multiple Languages: Examples in JavaScript, Python, PHP, cURL, Go, and Java

Quick start steps:

  1. Choose your endpoint: Start with /api/currency_converter/currencies to see available currencies
  2. Make your first call: Use /api/currency_converter/latest to get current rates
  3. Test conversion: Try /api/currency_converter/convert for currency conversion
  4. Integrate: Add the API calls to your application

FastTools.store provides everything you need to integrate currency data into your application quickly and efficiently.

8. What's the difference between FastTools and other currency APIs?

FastTools.store stands out from other currency APIs in several key ways:

  • Truly Free: No hidden costs, no credit card required, no trial periods
  • No API Key Required: Start using immediately without registration
  • Comprehensive Data: Real-time rates, historical data, and time series all included
  • Developer-Friendly: Clean API design with excellent documentation
  • Reliable Uptime: 99.9% uptime with redundant infrastructure

Comparison with competitors:

  • vs Paid APIs: Save thousands of dollars annually with our free tier
  • vs Limited Free APIs: Higher rate limits and more features than most free alternatives
  • vs Complex APIs: Simple, intuitive design that's easy to integrate
  • vs Unreliable APIs: Consistent performance and reliable data sources

FastTools.store is built by developers for developers, focusing on simplicity, reliability, and accessibility.

9. Can I use FastTools Currency API for commercial applications?

Absolutely! FastTools.store encourages commercial use of our currency API:

  • Commercial License: Free for commercial applications and businesses
  • No Restrictions: Use in SaaS applications, mobile apps, websites, and more
  • Revenue Generation: Build profitable applications using our API
  • White-Label Solutions: Perfect for financial services and fintech applications
  • Enterprise Ready: Suitable for large-scale applications and high-volume usage

Common commercial use cases:

  • E-commerce Platforms: Multi-currency pricing and checkout
  • Financial Apps: Portfolio tracking and investment tools
  • Travel Websites: Currency conversion for bookings
  • Accounting Software: Multi-currency invoicing and reporting
  • Cryptocurrency Exchanges: Fiat currency conversion

We only ask that you don't resell our API as a standalone service. Contact us if you have questions about specific use cases.

10. How reliable is FastTools Currency API? What about uptime?

FastTools.store is built for reliability and performance:

  • 99.9% Uptime: Industry-leading reliability with redundant infrastructure
  • Global CDN: Fast response times worldwide
  • Automatic Failover: Multiple data sources ensure continuous service
  • Real-time Monitoring: 24/7 monitoring and alerting
  • Regular Backups: Data protection and disaster recovery

Technical infrastructure:

  • Cloud Infrastructure: Scalable cloud-based architecture
  • Load Balancing: Automatic traffic distribution
  • DDoS Protection: Advanced security measures
  • SSL Encryption: Secure data transmission
  • Regular Updates: Continuous improvements and security patches

FastTools.store is designed to handle high-volume traffic and provide consistent performance for your applications.

11. What programming languages and frameworks work with FastTools API?

FastTools Currency API works with virtually any programming language that can make HTTP requests:

  • Web Languages: JavaScript, TypeScript, HTML/CSS
  • Backend Languages: Python, Node.js, PHP, Ruby, Go, Java, C#
  • Mobile Development: React Native, Flutter, Swift, Kotlin
  • Desktop Apps: Electron, .NET, Qt, GTK
  • Data Science: R, MATLAB, Julia

Popular frameworks and libraries:

  • Frontend: React, Vue.js, Angular, Svelte
  • Backend: Express.js, Django, Flask, Laravel, Spring Boot
  • Mobile: React Native, Flutter, Xamarin
  • Testing: Jest, Mocha, Pytest, JUnit

Since FastTools API uses standard HTTP and JSON, it integrates seamlessly with any technology stack.

12. How do I handle historical currency data and time series?

FastTools.store provides comprehensive historical data capabilities:

  • Historical Rates: Get rates for any specific date
  • Time Series: Retrieve rates over date ranges up to 365 days
  • Multiple Currencies: Historical data for all supported currencies
  • Flexible Queries: Filter by specific currencies or get all rates
  • Date Validation: Automatic validation of date formats and ranges

Use cases for historical data:

  • Financial Analysis: Track currency trends and patterns
  • Reporting: Generate historical reports for accounting
  • Backtesting: Test trading strategies with historical data
  • Research: Academic and market research applications
  • Auditing: Verify past transactions and conversions

FastTools.store makes it easy to access and analyze historical currency data for any application.

13. What should I do if I exceed the rate limits?

If you exceed FastTools API rate limits, here's how to handle it gracefully:

  • Check Headers: Monitor X-RateLimit-Remaining and X-RateLimit-Reset headers
  • Implement Backoff: Use exponential backoff when you hit limits
  • Cache Responses: Store frequently accessed data locally
  • Batch Requests: Combine multiple requests when possible
  • Optimize Usage: Only request data you actually need

Best practices to avoid rate limits:

  • Smart Caching: Cache currency rates for 5-10 minutes
  • User-Based Limits: Implement per-user rate limiting in your app
  • Error Handling: Gracefully handle 429 responses
  • Monitoring: Track your API usage patterns
  • Alternative Sources: Have fallback data sources for critical applications

Remember that FastTools.store provides generous free limits. If you consistently exceed them, consider optimizing your implementation or contact us for higher limits.

14. How do I ensure my FastTools API integration is secure?

Security is crucial when integrating any API. Here are FastTools.store security best practices:

  • Use HTTPS: Always make requests over HTTPS to encrypt data
  • Validate Responses: Always validate API responses before using data
  • Handle Errors: Implement proper error handling to prevent data leaks
  • Input Validation: Validate all user inputs before sending to API
  • Secure Storage: If using API keys, store them securely

Additional security measures:

  • Rate Limiting: Implement client-side rate limiting
  • Logging: Log API calls for monitoring and debugging
  • Testing: Test error scenarios and edge cases
  • Updates: Keep your integration updated with API changes
  • Monitoring: Monitor for unusual patterns or errors

FastTools.store uses industry-standard security practices, but proper integration security is your responsibility.

15. Can I get support or help with FastTools Currency API?

FastTools.store provides comprehensive support options:

  • Documentation: Detailed guides, examples, and reference materials
  • Live Converter: Test conversions directly on our website
  • Code Examples: Ready-to-use code snippets in multiple languages
  • Community Support: Developer community and forums
  • Direct Contact: Reach out for specific questions or issues

Support resources available:

  • API Documentation: Complete reference with examples
  • Troubleshooting Guides: Common issues and solutions
  • Best Practices: Optimization and security guidelines
  • Changelog: Updates and new features
  • Status Page: Real-time API status and uptime

FastTools.store is committed to helping developers succeed with our currency API. We're here to support your integration and answer any questions you may have.