Free stock API: what free tiers really include, and their limits

A free stock API is a stock data service you can call without paying, in exchange for limits: a monthly or daily request cap, a rate limit, often delayed or end-of-day prices, a narrower symbol list, and a license that usually allows personal use but not commercial display. TickerLayer's free tier is 3,000 REST requests a month with no card, on the same stock API routes paid plans use.

Lists of "the best free stock APIs" go stale within a year because vendors change their quotas. The categories do not change. This guide sorts free tiers into the types you will actually meet, shows how to do the arithmetic on a quota, covers the licensing questions most comparisons skip, and ends with a five-minute test you can run against any provider.

The five kinds of free stock API

The last row deserves a warning of its own. Libraries that read prices out of public finance websites are free and convenient until the page layout changes, the site starts rate-limiting your IP, or someone asks where the numbers came from. They are fine in a notebook. They are a liability in anything that runs unattended or that other people rely on.

TickerLayer sits in the third row: REST requests on the same endpoints as paid plans, capped at 3,000 a month, with no end date. The pricing page heads it "Free tier always available", and every new account starts on it.

The limits that decide what you can build

• Request quotaA monthly or daily cap on calls. It sets how many symbols you can track and how often you can ask.
• Rate limitCalls per second or per minute. Bursts at the open, or on a page that loads ten tickers at once, hit it first.
• DelayReal-time, 15 minutes behind, or end-of-day. Delayed prices are fine for charts and wrong for alerts.
• Coverage and historyUS only or other markets too, and how many years of bars. Free tiers are often vague about both.
• StreamingWebSocket access is the feature free tiers most often leave out.
• LicensePersonal use, internal use, or display to other people. The most expensive limit to discover late.

The quota is the one to do arithmetic on, because polling is expensive. Every REST request is one symbol at one moment, so the monthly cost of a polling loop multiplies quickly:

The same quota goes a long way once you stop polling prices and start asking for bars. A single call to the aggregates route returns up to 5,000 bars per page, so a year of daily history for one symbol (about 252 bars) is one request. Fetch history once, store it, and spend one request per symbol per day on the newest bar with GET /stocks/agg/{symbol}/prev.

Licensing: the limit free tiers do not advertise

Price data is licensed, not sold. The organizations that produce it charge differently depending on who sees the numbers and what they are used for, and every data provider passes those terms down to you. Three distinctions decide whether a free tier fits your project:

• Display versus non-display. Showing prices to a person on a screen is display. Feeding them to an algorithm, a risk model or a calculation that nobody looks at is non-display. Many licenses price and permit the two differently.
• Personal versus commercial. Using data for your own research is almost always allowed. Showing it to customers, subscribers or the public usually is not, on free tiers and on many personal paid plans too.
• Redistribution. Passing raw prices on to someone else, through your own API, a file export or an embeddable widget, needs explicit rights. Derived numbers such as an indicator or a ranking are sometimes treated differently, but read the terms instead of assuming.

TickerLayer says this on its pricing cards: Individual plans are for personal or research use, and Business plans include commercial use. The public symbol pages on this site show prices 15 minutes delayed, while the API serves live data to entitled keys (latency varies by stock market). If you are unsure where your project falls, read the terms of use before you ship, not after a customer asks.

What the TickerLayer free tier includes

• REST access with the x-api-key header, on the same routes and JSON shapes as paid plans.
• Symbol discovery (GET /stocks/symbols, POST /symbols/coverage) and market status, sessions and holidays under /markets.
• The MCP server for AI agents, which is included with every plan, the free tier among them.
• No WebSocket by default: streaming comes with paid plans, and free accounts can request a trial from the dashboard.

Which markets a key reaches is a property of the key, and the API will tell you: GET /stocks/symbols?market=US lists the stocks your key can use, and the coverage checker marks each symbol with the access it needs. A request rejected by the per-second limit does not count against the month, because rate limits are checked first. The limits documentation has the current defaults.

{
  "error": "REST_QUOTA_EXCEEDED",1
  "message": "monthly REST quota exceeded",
  "limit": 30002
}

Handle the two 429s differently: sleep and retry the per-second one, stop and alert on the monthly one. The 429 Too Many Requests guide covers both in depth.

How to make 3,000 requests last

• Ask for bars, not prices. One aggregates request returns a whole range; a price request returns one moment.
• Cache per render, not per visitor. If a page shows a price, fetch it once per minute on the server and serve every visitor from that copy.
• Skip closed markets. GET /markets/status?asset=stocks&market=US returns next_open and next_close, so a job can sleep until the session starts instead of polling a closed market all weekend. Note that is_open is also true in pre-market; check status equals open for the regular session.
• Read closes from prev. GET /stocks/agg/{symbol}/prev returns the last completed daily bar (with the official close for US stocks), one request per symbol per day.
• Normalize symbols once. Run your ticker list through the coverage checker a single time and store the qualified symbols, instead of retrying guesses.

Test a free stock market API in five minutes

1. 1Create an accountSign up and copy the key from the dashboard. The free tier needs no card.
2. 2Export the keyKeep it out of source code: set TICKERLAYER_API_KEY in your shell or secrets manager.
3. 3Make one requestFetch a snapshot and look at the timestamps, not only the price.
4. 4Read the headersx-ratelimit-limit and x-ratelimit-remaining show your per-second budget.
5. 5Break it on purposeAsk for KO without a market prefix and confirm you get a clear 400, not a guess.

export TICKERLAYER_API_KEY="YOUR_API_KEY"

# 1. A price, with its timestamps
curl -sS "https://api.tickerlayer.com/stocks/snapshot/US:KO" \
  -H "x-api-key: $TICKERLAYER_API_KEY"

# 2. The rate-limit headers only
curl -sS -o /dev/null -D - "https://api.tickerlayer.com/stocks/quote/US:KO" \
  -H "x-api-key: $TICKERLAYER_API_KEY" | grep -i ratelimit

# 3. A deliberate mistake: no market prefix
curl -sS "https://api.tickerlayer.com/stocks/quote/KO" \
  -H "x-api-key: $TICKERLAYER_API_KEY"

{"symbol":"US:KO","bid":88.11,"ask":88.24,"bid_size":400,"ask_size":1000,"last_price":88.24,"last_timestamp":1790589160160,"prev_close":87.81,"change":0.43,"change_percent":0.4897,"last_size":150}
x-ratelimit-limit: <requests allowed per second>
x-ratelimit-remaining: <requests left this second>
x-ratelimit-policy: <limit>;w=1
{"statusCode":400,"message":"invalid symbol"}

Run the same three checks against every provider on your shortlist. A free tier that returns prices without timestamps, guesses at ambiguous tickers, or hides its limits until you hit them will cost more in debugging than a paid plan costs in money. For the same flow in Python, with retries and a pandas DataFrame, follow the Python stock prices tutorial.

When to move off a free tier

If you are comparing providers rather than tiers, the financial data providers guide compares exchange-direct feeds, aggregators and free-tier APIs. Pricing lists every feed and market.