Alpaca Trading Platform: What You Need to Know

Opening — Who this guide is for and what it solves

You building algos, embedding brokerage into an app, or evaluating a low-cost broker for US equities will benefit. Read this if you want programmatic trade execution, not a fancy retail GUI. This guide clarifies what the term alpaca trading platform means. Expect a clear split between Alpaca’s two core services and actionable steps to decide for or against it.

What this solves: remove ambiguity about whether Alpaca is a “platform” or an API-backed broker. Show how the API (software interface) and the brokerage interact. Give concrete numbers for fees, limits, and times. Provide integration notes and real workflows. End with a short decision tree so you can choose the right route in under 5 minutes.

What you’ll get from this guide:
– Clear definitions of the two services and market reach.
– How the API works, including protocols and rate limits.
– Pricing with concrete numbers to budget for.
– Developer tooling and integration patterns.
– Three realistic use cases with step counts and timelines.
– A concise comparison table and a final decision tree.

Quick answer / TL;DR — Key takeaways you can act on now

Alpaca is an API-first brokerage. It offers two core services: a licensed self-clearing brokerage and a developer API (not a retail GUI). If you want embedded investing inside your app, use Alpaca’s Broker API. Over 100 fintechs already integrate; the platform powers 9,000,000+ accounts across 40+ countries. If you need a retail GUI with native options or futures, skip Alpaca. It focuses on US equities (10,000+ tickers) and partner crypto. Quick-start: sign up, complete KYC, test on paper, then fund via ACH (bank transfers typically take 3–5 business days).

Definition and positioning — 2 core services and market reach

Define Alpaca in two lines. It offers (1) a self-clearing brokerage that executes exchange-based orders and handles clearing and custody, and (2) an API (software interface) toolkit that lets developers transact programmatically. Treat the brokerage as the regulated back end. Treat the API as developer plumbing.

Alpaca is “not a platform” in the retail GUI sense. It does not primarily ship a full-featured trading client. Instead, third parties build front ends that connect via API. Expect integrations from mobile apps, web dashboards, and charting platforms. Alpaca powers 100+ companies and supports 9,000,000+ brokerage accounts in 40+ countries. Use those numbers to size the ecosystem.

Summarize asset and market scope. Core coverage centers on US-listed equities and ETFs, with 10,000+ US equities referenced through integrations. Crypto support exists through partners and brokered channels. Order routing and clearing target the two primary US exchanges. You should expect standard exchange settlement rules and cross-checks.

Practical implication for you: treat Alpaca as backend plumbing rather than a daily GUI. Design your product or strategy around two services:
– Brokerage: custody, clearing, settlement.
– API: account management, orders, market data.
Plan for 2 distinct integrations if you embed: user-facing app and server-side broker connector.

How the API works — protocols, flows, and concrete specs

Protocols and endpoints. Interact via REST for account management, positions, and historical data. Use WebSocket for live market data and real-time order updates. Authenticate using an API key and a secret key pair. Expect token pairs per environment: one for paper, one for live.

Typical request flow:
1. Create or link an account via Broker API endpoints. Expect 1–3 API calls.
2. Place an order using POST /orders. Orders may be market, limit, or stop.
3. Receive execution updates over WebSocket with per-order event messages.
4. Poll GET /positions and GET /account for state reconciliation.
Many algos push sub-second order submissions. Design for both synchronous POSTs and asynchronous WebSocket events.

Data and instruments:
– 10,000+ US equities and ETFs available.
– Some instruments support fractional shares down to 1/1000ths or per-share fractions.
– Select crypto instruments available via partner endpoints.
– Trading windows: standard session plus extended hours, typically 24/5 for some crypto flows and extended-equities windows of 4 hours pre/post session.

Rate limits and reliability:
– Expect limits in the range of dozens to hundreds of requests per minute per endpoint.
– Use exponential backoff for 429 responses.
– Track changelogs; Alpaca publishes auto-generated API changelogs.
– Test on paper first: simulate 100–10,000 orders before scaling to live volumes.

Watch out for:
– Treat paper and live keys as separate. Do not mix credentials.
– Monitor median latency and 95th percentile spikes if you run high-frequency flows.

Account types, pricing, and fees — concrete numbers to budget for

Fee model overview. Equity trades are commission-free on a per-trade basis (0% commission per trade). Alpaca earns from two main lines: interest on cash and margin loans, plus other service fees such as securities lending. Expect revenue from margin interest and lending to drive costs.

Account types and balances:
– Cash accounts: settle in T+2 for most equities. Use only settled funds for withdrawal and margin-ineligible trades.
– Margin accounts: require approval and enable borrowing. Margin interest rates vary; expect ranges from about 5% to 12% APR depending on borrowed amount and credit profile.
– Minimum balance: basic accounts may have $0 minimum; margin accounts usually require approval and potentially a $2,000 pattern-day trading threshold for unrestricted day trading.

Funding and clearing:
– ACH bank transfers typically take 3–5 business days to fully settle.
– Wire transfers settle faster: same day or 1 business day depending on cutoffs, but wire fees may apply from your bank.
– Some local funding via partners supports local-currency transfers and conversions. Expect currency conversion fees and 1–2% conversion spreads in some routes.

Hidden costs and limits:
– No native options or futures trading via the core API. That is one significant limitation.
– Margin interest adds cost when you borrow. Shorting incurs borrowing fees; rates depend on availability.
– Regulatory fees per trade still apply. These are small, often cents per trade, but add up with high volumes.
– Account transfers (ACATS) may have fees and take 3–7 business days.

Watch out for:
– Do not assume all instruments allow fractional trading. Check symbol-level metadata.
– Confirm margin rates for your expected borrow amounts before deploying large positions.

Integration and developer features — tooling and ecosystem

SDKs and client libraries. Use official and community SDKs for common stacks: Python, JavaScript, and others. Expect auto-generated client bindings and example code. Many SDKs include functions for REST calls and WebSocket handling, reducing boilerplate by 50% compared to raw HTTP.

Embeddable features and partner use:
– Over 100 companies embed Alpaca’s Broker API.
– Capabilities you can expose: custodial brokerage accounts, fractional shares, securities lending, and high-yield cash products.
– Examples of features you can offer: fractional buys as small as $1, custodial accounts for children, and local-currency funding in select markets.
– Broker API reduces time-to-market compared with building clearing relationships from scratch, often cutting integration time from 12–18 months to 3–6 months.

Monitoring, testing, and paper trading:
– Use paper trading to validate flows. Run 10–100 automated orders for unit tests.
– Run longer endurance tests: 1000+ simulated orders across 7–30 days to validate stability.
– Monitor metrics: request rate, 429s, median latency, and order fill rate.
– Implement retries with jitter and exponential backoff for rate-limit responses.

Ops and scaling notes:
– Design for API rate limits and scale horizontally.
– Implement idempotency keys for order submission to avoid duplicates.
– Track execution latency at median and 99th percentile. A good baseline is median <200 ms and 99th <1,000 ms for execution acknowledgments in many deployments.
– Build circuit breakers to pause trading after 3–10 consecutive failures.

Watch out for:
– Avoid hard-coded timeouts. Use adaptive timeouts based on measured latency.
– Expect maintenance windows. Schedule deployments with weekly or monthly checks.

Concrete use cases and example workflows — numbers and scenarios

Retail algo trader:
– You run a strategy placing 10–1,000 orders per day.
– Start by backtesting on historical data for 100,000+ minutes or 10,000+ ticks.
– Then test in paper trading for 7–30 days with 100–1,000 simulated trades.
– Move to live with margin approval if needed and monitor real fills and slippage.
Workflow steps:
1. Sign up and complete KYC (1 API call).
2. Generate API keys (2 keys: paper and live).
3. Backtest and validate on 10–100 symbols.
4. Paper trade for 7–30 days and 100–1,000 trades.
5. Go live and monitor 24/7 with alerts.

Fintech embedding investing:
– A fintech wants to onboard 10,000 users quickly.
– Use Broker API to create accounts, fund them, and execute trades.
– Typical integration uses 2–3 core endpoints: account creation, funding initiation, and trade submission.
– Time-to-market: reduce from 12–18 months to 3–6 months.
Capabilities to expose:
– Custodial accounts for minors.
– Fractional trading down to $1 or 0.001 shares.
– Local funding for markets in which you operate: support in 1–10 currencies via partners.
Workflow example:
1. Integrate authentication and account creation (3–5 endpoints).
2. Enable funding with ACH or local rails (2 flows: ACH, wire).
3. Expose trading and portfolio views (3–6 endpoints).

Backtesting and automated deployment:
– Backtest on historical bars: 1M+ rows for robust signals.
– Run paper trading for 7–30 days with 100+ simulated trades.
– Add monitoring: set thresholds for 5% portfolio drawdown and 2% intraday loss to trigger circuit breakers.
– Deploy with staged rollout: 10 accounts, 100 accounts, then 1,000+ accounts.

TradingView and third-party integrations:
– Connect Alpaca to chart platforms using REST keys and WebSocket.
– Continue to use visual analysis while sending orders programmatically.
– Expect a 2–5 minute setup for TradingView webhook-to-API automation.

Watch out for:
– Verify symbol mapping between your historical data and Alpaca tickers. Some tickers change or split.
– Account for slippage; simulate 0.05%–1% slippage in stress tests.

Risks, limitations, and compliance — concrete constraints to plan for

Asset coverage limits:
– Key limit: primarily US equities and ETFs, roughly 10,000+ tickers.
– No native options or futures trading on the core API.
– Forex and international equity markets are limited or available only via partners.
Plan around this by using a secondary broker if you need a full asset suite.

Regulatory and custody risks:
– Alpaca is a self-clearing broker-dealer. That means it holds custody and clears trades.
– Complete KYC/AML checks before account activation. Automated approvals are common, but some reviews take 2–3 business days.
– Margin approval is manual in many flows and may take 1–3 business days.

Operational risks:
– Expect occasional outages and maintenance windows.
– Mitigate with retries, circuit breakers, and fallback order routes.
– Rate limits force backoff; design for 429 responses and 1–5 second retry windows.
– Keep a backup plan if execution latency exceeds normal thresholds, such as pausing strategies after 3 failed submissions.

Cost surprises:
– Commission is 0% per trade, but other fees exist.
– Margin interest ranges from about 5% to 12% APR depending on borrow.
– Shorting may cost variable borrow fees, which can spike to double-digit percentages for hard-to-borrow shares.
– Securities lending and revenue-sharing with partners can affect returns.

Watch out for:
– Do not assume zero cost. Account for 3–10% annualized drag from interest and lending in leveraged strategies.
– Expect regulatory reporting obligations and tax forms for accounts exceeding threshold volumes.

Comparison table — quick side-by-side of common options

Use this table to compare Alpaca’s API-first model against typical alternatives so you can match needs with features and numbers.

Option	Access method	Asset scope	Typical fees	Best for
Alpaca (API-first broker)	API (REST + WebSocket)	10,000+ US equities, ETFs, partner crypto	0% commission per trade; margin/interest fees apply (5%–12% APR)	Embedding brokerage; algos; fintechs (100+ partners)
Traditional retail broker (GUI)	Web/mobile client	US equities + options + futures + forex	0%–$0.65 per options contract; variable commissions for other assets	Individual traders wanting built-in GUI and full asset access
Algo execution platform with GUI	API + platform UI	Varies (often US equities + some options)	Platform fees + execution fees; tiered pricing	Strategy developers who want bundled backtests and managed execution

Alpaca stands out for API access and embedding. It offers low per-trade commission and a large instrument list. It lags when you need native options, futures, or a built-in retail UI.

Closing — How to choose / bottom line decision tree

Follow this quick decision tree. It takes 1–3 minutes and uses concrete checks.

Need a retail GUI with native options/futures?
Yes → Choose a traditional retail broker with GUI. Expect 1 app, options chains, and per-contract fees around $0.00–$0.65.
No → Continue.
Want to embed investing into your app or power algos?
Yes → Use Alpaca’s Broker API. Expect to integrate 2–3 core endpoints and launch in 3–6 months for 10,000 users.
No → Continue.
Need full multi-asset access (options, futures, forex)?
Yes → Pick a full-service broker or layered solution; expect extra clearing relationships and 12–18 months to integrate.
No → Alpaca fits. Plan for 10,000+ tickers and 0% per-trade commission.
Scale concerns: will you run 10–1,000 orders per day or 1,000+ per day?
10–1,000 → Alpaca paper test then live is adequate. Run 7–30 days of paper trading and 100–1,000 simulated trades.
1,000+ → Plan capacity testing: simulate 10,000+ orders and measure median and 99th percentile latency.

Bottom line actions:
– Sign up and complete KYC if you want to test. Expect 1–3 business days for most approvals.
– Test on paper for 7–30 days. Execute 100–1,000 test trades.
– Fund via ACH (3–5 business days) or wire (same day or 1 business day).
– Monitor margin usage and borrowing costs. Expect interest rates from about 5% to 12% APR depending on borrowing.

Decide quickly:
– Embed investing or run programmatic algos → Use Alpaca for lower integration time and API control.
– Need options, futures, or retail GUI → Use a traditional broker or a platform that bundles execution and a GUI.

Summary checklist before you commit:
– Confirm asset coverage for your top 10 symbols.
– Verify margin rates and borrowing fees for expected balances.
– Run paper trading for 7–30 days with 100–1,000 orders.
– Design for rate limits: expect dozens to hundreds of requests per minute.
– Build monitoring for median latency <200 ms and 99th percentile <1,000 ms.

Take action: Test, validate, and scale.