API Rate Limits vs API Throttling: Which Kills Your App First?

API rate limits and API throttling are two different ways providers control how fast you can pull data, and if you dont understand the difference you'll waste hours debugging why your app randomly stops working. Rate limits are hard caps — hit 500 requests and you're done until next month. Throttling is softer — you can keep making calls but the API slows you down or queues your requests instead of blocking you completely.

• What is an API rate limit?
• What is API throttling?
• How to check your API rate limits in real-time
• Best free API for developers in 2026
• REST API vs WebSocket for real-time data
• Frequently Asked Questions

What is an API rate limit?

An API rate limit is a hard monthly or per-minute cap on how many requests you can make before the API returns a 429 error and blocks you. Most forex APIs use monthly limits — Alpha Vantage gives you 25 calls per day on the free tier, Twelve Data gives 800 per day, and FCS API gives 500 per month but no daily restriction so you can burn through them all in one session if you need to backtest something fast. The problem with monthly caps is they dont tell you anything about burst speed. You could have 10,000 monthly calls but if the per-minute limit is 5 requests your trading bot is useless.

FCS API splits it clearly: 500 monthly calls on free, 3 requests per minute. The api rate limits page shows exactly what you get at each tier — Pro plan is 200k monthly calls at 40 req/min for $10/month which is cheaper than Twelve Data's $29 entry plan that only gives you 8 req/min. If you're polling multiple pairs every second the per-minute number matters more than the monthly total.

What is API throttling?

API throttling doesnt block you, it slows you down by adding delays or queuing your requests when you exceed the rate. Some APIs return a Retry-After header telling you to wait 3 seconds before trying again. Others just process your request slower — you send 100 calls in one second and the API queues them to drip out at 10 per second instead of rejecting 90 of them. This is better for apps that can tolerate slight delays but worse if you need guaranteed sub-second response times.

Most financial APIs dont throttle, they just hard-block you. Polygon.io blocks at 5 req/sec on their $29 plan. Finnhub blocks at 60 req/min on their $49 plan. FCS API blocks at the stated per-minute limit with no grace period but the limits are higher for the price — 40 req/min at $10/month vs Finnhub's 60 req/min at $49/month. The tradeoff is you know exactly when you'll hit the wall instead of guessing if your requests are being queued or dropped. I prefer hard limits because api throttling makes debugging a nightmare when half your requests succeed and half timeout with no clear pattern.

How to check your API rate limits in real-time

To check your rate limits you look at the response headers every API returns — most use X-RateLimit-Remaining to show how many calls you have left and X-RateLimit-Reset to show when the counter resets. Here's how you'd track it with FCS API:

import requests

response = requests.get('https://fcsapi.com/api-v3/forex/latest', params={
    'symbol': 'CAD/HKD',
    'access_key': 'YOUR_API_KEY'
})

remaining = response.headers.get('X-RateLimit-Remaining')
reset_time = response.headers.get('X-RateLimit-Reset')

print(f"Calls left: {remaining}")
print(f"Resets at: {reset_time}")

The JSON response for CAD/HKD today looks like this:

{
    "status": true,
    "code": 200,
    "msg": "Successfully",
    "response": [
        {
            "s": "o",
            "c": "5.72781",
            "h": "5.73456",
            "l": "5.71894",
            "ch": "-0.00063",
            "cp": "-0.011%",
            "t": "1745971200",
            "tm": "2026-04-30 00:00:00"
        }
    ]
}

You parse the "c" field for current price and "cp" for change percentage. If you hit your limit mid-session you get a 429 status code and an error message telling you to upgrade or wait. No throttling, no queuing, just a clean block.

Best free API for developers in 2026

The best free API in 2026 depends on what you're building. If you need US stocks only and dont care about indicators, Yahoo Finance API is still free but its unofficial and breaks randomly — I've had it go down for 3 days straight with no warning. If you need global coverage across forex, crypto, and stocks in one service, FCS API's 500 free calls beat Alpha Vantage's 25 per day because you can batch your testing instead of spreading it over 20 days.

For a trading bot that needs pivot points and technical indicators, FCS API is the only one that includes those on the free tier. Twelve Data makes you pay $29/month just to get SMA and EMA calculations. Alpha Vantage has indicators but the 25 daily call limit means you cant poll more than 2-3 symbols in real-time.

REST API vs WebSocket for real-time data

REST API makes you poll the server every X seconds to check for price updates — you send a GET request, get back the latest price, wait, send another request. WebSocket opens a persistent connection and the server pushes updates to you the moment they happen. For real-time forex data WebSocket is better because you dont waste API calls checking if the price changed when it didnt.

FCS API supports both. The REST endpoint for CAD/HKD returns the current price of 5.72781 with a -0.011% change from open. If you're polling this every 10 seconds you burn through 6 calls per minute just for one pair. With WebSocket you subscribe once and get pushed every tick with no additional call count. The free tier includes WebSocket access which is rare — most APIs charge extra for it or dont offer it at all. Polygon.io charges $29/month minimum for WebSocket and only covers US markets. FCS API gives you WebSocket for forex, crypto, and stocks starting at the free forex API tier.

The WebSocket integration tutorial is straightforward:

const WebSocket = require('ws');

const ws = new WebSocket('wss://fcsapi.com/ws?access_key=YOUR_KEY');

ws.on('open', function open() {
  ws.send(JSON.stringify({
    action: 'subscribe',
    symbols: ['CADHKD']
  }));
});

ws.on('message', function message(data) {
  const tick = JSON.parse(data);
  console.log(`${tick.symbol}: ${tick.price}`);
});

Every price update comes through as a JSON object with symbol, price, timestamp. You dont poll, you just react to incoming data. This is how high-frequency bots work — they cant afford the 200-500ms latency of a REST call every time they need to check a price.

Frequently Asked Questions

Is FCS API free to use?

Yes, FCS API has a free tier with 500 API calls per month and 3 requests per minute. You get access to forex, crypto, and stocks data with no credit card required. Paid plans start at $10/month for 200k calls.

What programming languages does FCS API support?

FCS API is language-agnostic because it uses standard REST and WebSocket protocols. You can call it from Python, JavaScript, PHP, Java, C#, Go, or any language that can make HTTP requests and parse JSON.

Does FCS API include technical indicators?

Yes, FCS API includes 50+ technical indicators like RSI, MACD, Bollinger Bands, ATR, and Parabolic SAR. It also provides pivot points and moving averages. Most competitors charge extra for indicators or dont offer them at all.

How many API calls are in the free tier?

The free tier includes 500 API calls per month with a rate limit of 3 requests per minute. This is enough for testing and small personal projects. Paid plans scale from 20k to 2.7M calls per month.

What data formats does FCS API return?

FCS API returns data in JSON format for both REST and WebSocket endpoints. Every response includes a status code, message, and a response array with the requested data fields like price, change, volume, and timestamps.

Start with the free tier if you're building a prototype or testing a strategy. If you need sub-10-second updates for multiple pairs, upgrade to the Pro plan at $10/month for 40 req/min and 200k monthly calls. Get your free API key at FCS API and try it yourself.