Alpaca pricing plans compared with Python data examples and limits

Alpaca pricing has two tiers. There's a free plan at $0 per month and a paid plan called Algo Trader Plus at $99 per month. The gap between them affects how fast you receive market data, how many API requests you can send per minute, and which stock exchanges your data comes from. If you build rule-based trading programs in Python, you need to know what each tier includes so you don't run into limits halfway through a project. You can walk through a full Alpaca setup and strategy guide before committing to either plan.

Alpaca's own pricing page shows a feature comparison table, but it doesn't explain what those features mean when you actually sit down to write code. This article fills that gap. We'll show what each plan includes, then look at the free tier's limits and pull market data with Python to see those limits in practice. If you're also curious about Alpaca's trading fees (the commissions and regulatory charges on actual trades, which are separate from data pricing), that guide covers the brokerage side.

Alpaca Pricing Free Plan: What You Get

The free plan costs nothing. It includes US stock data and crypto data, plus corporate actions such as stock splits and dividends. You also get over seven years of historical data, which is enough to check how a trading rule would have behaved on past prices.

The constraints are real, though. API calls are capped at 200 per minute. That sounds generous until you start pulling minute-level price bars for hundreds of stocks. Even with batch requests, scanning a broad list of tickers can use up that limit quickly.

Data latency is the bigger issue. On the free plan, REST API data runs 15 minutes behind the live market. Don't use 15-minute delayed REST prices to make time-sensitive live trading decisions. You can get real-time data through websockets (a persistent connection that streams prices as they happen), but the free plan limits you to 30 symbols at a time. If you're tracking a small portfolio, that works. If you want to watch hundreds of tickers, it won't.

Exchange coverage is another limit. The free plan only pulls data from IEX (the Investors Exchange), which handles a small fraction of total US stock volume. In practice, a stock might show lighter volume or slightly different intraday highs and lows on IEX compared to the full market across NYSE, Nasdaq, and other trading venues. For end-of-day research on broad price moves, IEX data is usually close enough. But if you're studying volume patterns or short-term price behavior, the missing exchange data can skew your results.

Options data on the free plan is labeled "indicative." That means the option price you see may differ from the actual best bid and ask available in the market at that moment. You can browse which options contracts exist and get a rough sense of pricing, but you can't rely on those numbers for precise execution. If you're exploring options trading platforms, keep that distinction in mind.

Alpaca Pricing Plus Plan: What $99 per Month Adds

The paid tier removes the main limits on request volume, symbol count, and exchange coverage. API calls become unlimited, so you can pull data for thousands of symbols without getting throttled. Websocket streaming covers unlimited symbols instead of 30. Your data also comes from all US exchanges, not just IEX.

"Unlimited" in this context still assumes normal use. Alpaca may enforce platform-level protections if traffic looks abusive, so don't expect to hammer the API with millions of requests per hour without consequences.

Real-time options data from OPRA (the Options Price Reporting Authority, which is the official source for US options prices) is the other major upgrade. The free plan's approximate quotes aren't good enough if you need to place options orders at competitive prices. The paid plan gives you actual bid and ask prices as they update.

For someone checking a handful of stocks, the free plan does the job. The $99 per month plan makes sense when you need to scan broad markets in real time or trade options with accurate pricing. Many standalone market data products charge several hundred dollars per month for real-time data from all US exchanges, so Alpaca's paid tier is on the cheaper end of that range.

Pulling Alpaca Market Data With Python

Here's what the free plan looks like when you use it from Python. The code below uses Alpaca's official Python SDK to pull historical price bars and a real-time snapshot for a single stock. You'll need an Alpaca account and API keys, which you can generate from the Alpaca dashboard after signing up. The Alpaca getting started docs walk through that process.

Start by installing the SDK. The alpaca-py package pulls in pandas as a dependency, so you don't need to install pandas separately.

pip install alpaca-py

Next, pull daily price bars for Apple over the last 30 days.

from alpaca.data.historical import StockHistoricalDataClient
from alpaca.data.requests import StockBarsRequest
from alpaca.data.timeframe import TimeFrame
from datetime import datetime, timedelta

# Replace with your own API keys from the Alpaca dashboard
API_KEY = "your_api_key"
SECRET_KEY = "your_secret_key"

client = StockHistoricalDataClient(API_KEY, SECRET_KEY)

# Request daily bars for AAPL over the past 30 days
request_params = StockBarsRequest(
    symbol_or_symbols="AAPL",
    timeframe=TimeFrame.Day,
    start=datetime.now() - timedelta(days=30),
    end=datetime.now(),
)

bars = client.get_stock_bars(request_params)
df = bars.df

print(df.head())
print(f"\nRows returned: {len(df)}")
print(f"Columns: {list(df.columns)}")

This returns a pandas DataFrame with columns for open, high, low, close, volume, trade count, and VWAP (volume-weighted average price, which is the average price weighted by how many shares traded at each price level throughout the day). Each row is one trading day. One thing to watch for is that timestamps come back in UTC (Coordinated Universal Time), so they may not match your local market clock. US market hours are Eastern Time, four or five hours behind UTC depending on daylight saving time.

If the request fails, check that your API keys are correct and that your account has the right data permissions enabled in the Alpaca dashboard.

On the free plan, this historical data comes from IEX only. The prices reflect IEX trades but won't include volume from NYSE or Nasdaq. For daily bars used in broad research on price direction, that's usually adequate. For anything that depends on accurate volume numbers or sub-minute price detail, the gaps matter more.

Checking Real-Time Snapshots

A snapshot gives you the latest quote and trade for a stock in a single API call.

from alpaca.data.requests import StockSnapshotRequest

snapshot_request = StockSnapshotRequest(symbol_or_symbols="AAPL")
snapshot = client.get_stock_snapshot(snapshot_request)

aapl = snapshot["AAPL"]
print(f"Latest trade price: ${aapl.latest_trade.price}")
print(f"Latest trade size: {aapl.latest_trade.size} shares")
print(f"Bid: ${aapl.latest_quote.bid_price}")
print(f"Ask: ${aapl.latest_quote.ask_price}")
print(f"Daily bar close: ${aapl.daily_bar.close}")

On the free plan, this snapshot data has a 15-minute delay through the REST API. If you run this during market hours, the "latest" trade might actually be 15 minutes old. The paid plan returns current prices.

Streaming Real-Time Data

To get live prices without delay on the free plan, use websockets. This example streams trades for up to 30 symbols.

from alpaca.data.live import StockDataStream

stream = StockDataStream(API_KEY, SECRET_KEY)

async def handle_trade(trade):
    print(f"{trade.symbol}: ${trade.price} ({trade.size} shares)")

# Subscribe to real-time trades (free plan: max 30 symbols)
stream.subscribe_trades(handle_trade, "AAPL", "MSFT", "GOOGL")
stream.run()

This prints each trade as it happens. The free plan caps you at 30 symbols per websocket connection. The paid plan removes that cap entirely. If you want to automate trading through the Alpaca API, using this streaming data with order submission is the typical approach.

Which Alpaca Pricing Plan Should You Choose

The free plan is a good starting point for most people. It gives you enough data to learn the API and check how a trading rule would have worked on past prices. You can also run simple live rules on a small set of stocks. Alpaca's paper trading mode (simulated trading with fake money) works on the free plan too, so you can practice without risking real capital.

Upgrade to the $99 per month plan when the free plan's limits start to block your work. That usually means you need real-time REST data instead of 15-minute delayed quotes, you want to stream more than 30 symbols at once, you're trading options and need accurate OPRA quotes, or you make enough API calls that the 200-per-minute cap slows you down.

One important distinction is that Alpaca pricing for market data is separate from trading commissions. Alpaca charges zero commission on stock trades, though small regulatory fees (charged by FINRA and the SEC, not by Alpaca) still apply at every broker. The data subscription affects the speed and coverage of the market data you receive. It does not change what Alpaca charges to place orders.

Go Deeper

Both Alpaca pricing tiers give you enough to start writing Python code against real market data. The free plan handles learning and small-scale research. The paid plan handles larger real-time market scans and options work. Pick the one that matches what you're actually doing today, and upgrade when you outgrow it.

The free Algorithmic Trading With Python guides go deeper on this, showing how to build and test rule-based trading strategies (trading methods that follow fixed instructions instead of human judgment) using the data you've just learned to pull.