How to Build a Crypto Trading Bot with Alpaca

Automated crypto trading involves programmatic execution of buy and sell orders based on predefined conditions, typically derived from price data and technical signals. Alpaca's Crypto API provides REST and streaming endpoints that can help developers build bots capable of fetching real-time data, evaluating signals, and submitting orders programmatically. Any automated system still requires ongoing human oversight and monitoring.

This guide covers how to fetch live and historical crypto bar data using Alpaca's Market Data API, calculate a simple moving average (SMA) crossover signal in Python, and submit crypto orders through Alpaca's Trading API. All examples use Alpaca's paper trading environment and are strictly educational.

NOTE: This article is for general informational and educational purposes only and is not intended as investment, legal, or tax advice. All examples are illustrative only and do not represent actual or expected results.

This content was prepared by a third party that received compensation for its creation. The views and opinions expressed are those of the third party and do not necessarily reflect the views of Alpaca. This content has not been independently verified by Alpaca and does not constitute a recommendation, endorsement, or solicitation to buy or sell any securities or cryptocurrencies.

Cryptocurrency is highly speculative in nature and involves a high degree of risk, including volatile market price swings, market manipulation, flash crashes, and cybersecurity risks. Cryptocurrency regulations are continuously evolving, and it is your responsibility to understand and comply with applicable laws and regulations. Cryptocurrency trading can result in substantial and immediate loss of financial value. You should have appropriate knowledge and experience before engaging in cryptocurrency trading. For additional information, please click here.

Technical indicators and automated trading strategies are based on historical market data and may not reliably predict future market behavior. Automated trading systems may execute unintended trades due to coding errors, connectivity issues, market conditions, or inaccurate data inputs.

Cryptocurrency is highly speculative in nature, involves a high degree of risks, such as volatile market price swings, market manipulation, flash crashes, and cybersecurity risks. Cryptocurrency regulations are continuously evolving, and it is your responsibility to understand and abide by them. Cryptocurrency trading can lead to large, immediate and permanent loss of financial value. You should have appropriate knowledge and experience before engaging in cryptocurrency trading. For additional information, please click here. Technical indicators and automated trading strategies are based on historical market data and may not reliably predict future market behavior. Automated trading systems may execute unintended trades due to coding errors, connectivity issues, market conditions, or inaccurate data inputs. 

Past performance, whether actual or simulated, is not indicative of future results. Paper trading and backtesting results have inherent limitations and do not reflect actual market conditions such as liquidity, slippage, and execution risk.

Key Takeaways

• Alpaca's Crypto API supports REST-based historical data requests and WebSocket-based real-time streams for a range of cryptocurrency pairs
• A SMA crossover is one of many rule-based approaches some traders use to generate entry and exit signals; like all technical indicators, it carries inherent limitations and false signal risk
• Alpaca's alpaca-py SDK provides a CryptoHistoricalDataClient and a TradingClient that can help implement data ingestion and order submission in Python
• API keys must be stored in environment variables or .env files and must never be committed to version control
• Paper trading with paper=True can help test bot logic in a simulated environment using real market data before any live deployment is considered
• Cryptocurrency markets are highly volatile and operate continuously; automated bots require robust error handling, position management logic, and ongoing monitoring
• All examples in this guide are hypothetical and educational; no outcomes are guaranteed

What Is a Crypto Trading Bot?

A crypto trading bot is a software program that monitors market data and executes orders according to a defined set of rules. Instead of placing trades manually, a bot evaluates conditions at set intervals or in response to real-time data events, then submits orders programmatically through a trading API.

Bots are commonly used to:

• Attempt to apply technical indicator logic at defined intervals, though ongoing human oversight remains important
• Evaluate market conditions at frequencies that may be impractical to sustain through manual monitoring alone
• Log and track signals, order submissions, and position changes for review

It is important to note that automation does not reduce market risk. Bots execute logic as written, which means errors in strategy design or code can result in unintended order behavior. Cryptocurrency markets are open 24 hours a day, seven days a week, and are subject to high volatility and rapid price changes.

Prerequisites

Before working through the code examples in this guide, you will need:

• Alpaca’s Trading API account with crypto trading enabled (paper trading does not require funded capital)
• uv Python package manager
• Python 3.12 or later installed
• The following Python packages: alpaca-py, pandas, python-dotenv
• API keys from your Alpaca dashboard, stored securely as described below

Install the required packages:

!uv pip install alpaca-py pandas python-dotenv

For additional SDK details, refer to the Alpaca-py documentation and the Alpaca API documentation.

Step 1: Set up Alpaca API Access Using Environment Variables

API keys can be stored outside source files to help reduce the risk of accidental exposure. Using a `.env` file or environment variables is a common practice. Keys must never be committed to repositories. Add `.env` to your `.gitignore` file.

The following pattern supports both local development and Google Colab environments:

import os
from dotenv import load_dotenv
import sys

if "google.colab" in sys.modules:
    # In Google Colab environment, fetch API keys from Secrets.
    # Users should set ALPACA_API_KEY and ALPACA_SECRET_KEY
    # in Colab Secrets via the sidebar.
    from google.colab import userdata
    ALPACA_API_KEY = userdata.get("ALPACA_API_KEY")
    ALPACA_SECRET_KEY = userdata.get("ALPACA_SECRET_KEY")

else:
    # Store API keys safely and never commit them to repositories.
    # Use .gitignore for .env files.
    load_dotenv()
    ALPACA_API_KEY = os.environ.get("ALPACA_API_KEY")
    ALPACA_SECRET_KEY = os.environ.get("ALPACA_SECRET_KEY")

Your .env file should contain:
ALPACA_API_KEY="insert_key_here"
ALPACA_SECRET_KEY="insert_secret_here"

For production deployments, consider using a dedicated secrets manager such as AWS Secrets Manager or HashiCorp Vault rather than `.env` files. Never share API keys in public repositories, chat messages, or documentation.

Step 2: Get Crypto Historical Bar Data

To evaluate trading signals, your bot needs historical price data. Alpaca's Market Data API provides access to OHLCV (Open, High, Low, Close, Volume) bar data for a range of cryptocurrency pairs. The `CryptoHistoricalDataClient` in `alpaca-py` can help request this data programmatically.

Initialize the Crypto Data Client

from alpaca.data.historical.crypto import CryptoHistoricalDataClient

# Initialize without authentication for market data (free tier)
# or pass credentials for higher-tier access
crypto_historical_data_client = CryptoHistoricalDataClient(
    api_key=ALPACA_API_KEY,
    secret_key=ALPACA_SECRET_KEY
)

What this code does: It instantiates the data client, which provides methods to request crypto bars, quotes, and snapshots.

Why it exists: A single initialized client can be reused across multiple data requests within the same session, which may reduce overhead.

When to use this: Once at the start of your script, before any data fetching logic runs.

Request Crypto Historical Bars

from alpaca.data.requests import CryptoBarsRequest
from alpaca.data.timeframe import TimeFrame
from datetime import datetime, timedelta
import pandas as pd

def fetch_crypto_bars(
    symbol: str,
    lookback_days: int = 60
) -> pd.DataFrame:
    """
    Fetch daily OHLCV bars for a crypto symbol over a lookback window.

    Args:
        symbol: The crypto trading pair (e.g., 'BTC/USD').
        lookback_days: Number of calendar days of history to request.

    Returns:
        A pandas DataFrame indexed by timestamp with OHLCV columns.
    """
    request_params = CryptoBarsRequest(
        symbol_or_symbols=symbol,
        timeframe=TimeFrame.Day,
        start=datetime.now() - timedelta(days=lookback_days),
        end=datetime.now() - timedelta(days=1)
    )
    bars = crypto_historical_data_client.get_crypto_bars(request_params)
    df = bars.df

    # Flatten multi-index if symbol-level index is present
    if isinstance(df.index, pd.MultiIndex):
        df = df.xs(symbol, level="symbol")

    return df

What this code does: The `fetch_crypto_bars` requests daily bar data for a given crypto pair and returns a DataFrame of OHLCV values indexed by timestamp.

Why a 60-day lookback: Computing a 30-period SMA requires at least 30 data points. A 60-day window provides additional data to allow moving averages to stabilize before the most recent periods.

When to use this: Before any signal computation. This function can be called at the start of each strategy evaluation cycle.

For additional data coverage details, see Market Data API documentation.

Step 3: Compute a SMA Crossover Signal

A SMA crossover is one approach some traders may use to identify potential momentum shifts. It involves calculating two SMAs of different lengths over closing prices. When the shorter-period SMA crosses above the longer-period SMA, some traders interpret this as a potential signal that upward momentum may be increasing. When it crosses below, the interpretation may be the opposite.

Like all technical indicators, SMA crossovers are lagging signals derived from historical prices. They may produce false signals, particularly in sideways or low-volatility conditions.

Calculate SMAs

def compute_sma(df: pd.DataFrame, short: int = 10, long: int = 30) -> pd.DataFrame:
    """
    Add short and long SMA columns to a DataFrame of OHLCV bars.

    Args:
        df: DataFrame with a 'close' column.
        short: Period for the short-term SMA.
        long: Period for the long-term SMA.

    Returns:
        The input DataFrame with 'sma_short' and 'sma_long' columns added.
    """
    df = df.copy()
    df["sma_short"] = df["close"].rolling(window=short).mean()
    df["sma_long"] = df["close"].rolling(window=long).mean()
    return df

What this code does: The `compute_sma` function computes rolling averages of closing prices over two windows and appends them as new columns.

Why use rolling().mean(): This is the standard pandas method for computing simple moving averages over a fixed window. Review the pandas rolling documentation for more details.

When to use this: After fetching bar data and before running crossover detection logic.

Detect a Crossover Event

def detect_sma_crossover(df: pd.DataFrame) -> str:
    """
    Detect whether a bullish or bearish SMA crossover occurred
    on the most recent two bars.

    Args:
        df: DataFrame with 'sma_short' and 'sma_long' columns.

    Returns:
        'bullish', 'bearish', or 'none'.
    """
    if len(df) < 2:
        return "none"

    prev = df.iloc[-2]
    curr = df.iloc[-1]

    prev_diff: float = prev["sma_short"] - prev["sma_long"]
    curr_diff: float = curr["sma_short"] - curr["sma_long"]

    # Potential bullish crossover: short crosses above long
    if prev_diff <= 0 and curr_diff > 0:
        return "bullish"

    # Potential bearish crossover: short crosses below long
    if prev_diff >= 0 and curr_diff < 0:
        return "bearish"

    return "none"

What this code does: It compares the relative position of the two SMAs across the two most recent bars. A sign change in the difference indicates a crossover.

Why check two consecutive bars: A crossover is defined by a transition between periods, not by the value at a single point in time. Checking only the current bar cannot confirm a transition occurred.

When to use this: As part of the main strategy loop, after SMA values have been computed. This function returns a string label that downstream order logic can evaluate.

Step 4: Place Crypto Orders Based on SMA Crossover Signals

When a signal condition is met, your bot can submit orders through Alpaca's Trading API. The examples below use Alpaca's paper trading environment, which simulates order execution using real market data without involving real capital.

Note that crypto trading on Alpaca involves maker/taker fees based on your 30-day trading volume. Market orders, as used in the examples below, are filled as taker orders. These fees are not modeled in this educational example but may affect outcomes in both paper and live trading environments.

Initialize the Trading Client

from alpaca.trading.client import TradingClient

trading_client = TradingClient(
    api_key=ALPACA_API_KEY,
    secret_key=ALPACA_SECRET_KEY,
    paper=True  # Use paper trading environment
)

What this code does: It instantiates the trading client pointed at Alpaca's paper trading endpoint.

Why paper=True: This directs all requests to the paper trading environment, which can help test order logic without submitting live orders. For more on paper trading, see the Paper Trading documentation.

Submit a Market Order for Crypto

from alpaca.trading.requests import MarketOrderRequest
from alpaca.trading.enums import OrderSide, TimeInForce

def submit_crypto_market_order(
    symbol: str,
    qty: float,
    side: OrderSide
) -> None:
    """
    Submit a market order for a crypto pair.

    Args:
        symbol: The crypto pair (e.g., 'BTC/USD').
        qty: Quantity of the asset to order.
        side: OrderSide.BUY or OrderSide.SELL.
    """
    order_data = MarketOrderRequest(
        symbol=symbol,
        qty=qty,
        side=side,
        time_in_force=TimeInForce.GTC  # Good-Till-Canceled for crypto
    )
    order = trading_client.submit_order(order_data=order_data)
    print(f"Order submitted: {order.id} | Side: {side} | Qty: {qty}")

What this code does: The `submit_crypto_market_order` function creates and submits a market order for a given crypto pair, quantity, and side.

Why TimeInForce.GTC for crypto: Unlike equities, crypto markets operate continuously. `GTC` (Good-Till-Canceled) is commonly used for crypto orders since there is no daily session boundary. For the full list of supported order types and time-in-force options, see the Orders section of Alpaca's API documentation.

When to use this: When crossover detection returns an actionable signal and position checks confirm the order is appropriate.

Check an Existing Crypto Position

from alpaca.trading.client import TradingClient

def get_crypto_position(
    symbol: str
) -> None:
    """
    Return the open position for a crypto symbol, or None if no position exists.

    Args:
        symbol: The crypto pair (e.g., 'BTC/USD').

    Returns:
        A position object or None.
    """
    try:
        position = trading_client.get_open_position(symbol.replace("/", ""))
        return position
    except Exception:
        return None

What this code does: The `get_crypto_position` function queries Alpaca for any open position in the specified symbol. The / is stripped from the symbol string because Alpaca's position endpoint uses formats like `BTCUSD`.

Why check positions: To help reduce the likelihood of duplicate entries or to verify whether an exit signal can trigger a sell before submitting an order.

When to use this: Before any order submission, as part of the strategy's decision logic.

Step 5: Assemble a Hypothetical SMA Crossover Strategy

import logging

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger(__name__)

def run_sma_crossover_strategy(
    symbol: str = "BTC/USD",
    qty: float = 0.001,
    short_period: int = 10,
    long_period: int = 30,
    lookback_days: int = 60
) -> None:
    """
    Hypothetical SMA crossover strategy for a crypto pair.

    Fetches historical bar data, computes SMAs, evaluates a crossover
    signal, checks the current position, and conditionally submits
    a paper trading order.

    This is for educational purposes only. No outcomes are guaranteed.

    Args:
        symbol: Crypto trading pair (e.g., 'BTC/USD').
        qty: Order quantity in base asset units.
        short_period: Short SMA window in periods.
        long_period: Long SMA window in periods.
        lookback_days: Number of days of historical data to fetch.
    """
    logger.info(f"Running SMA crossover strategy for {symbol}")

    # Step 1: Fetch historical bar data
    df = fetch_crypto_bars(symbol=symbol, lookback_days=lookback_days)

    # Step 2: Compute SMAs
    df = compute_sma(df, short=short_period, long=long_period)

    # Step 3: Detect crossover
    signal: str = detect_sma_crossover(df)
    logger.info(f"Signal detected: {signal}")

    # Step 4: Check current position
    position = get_crypto_position(symbol)

    # Step 5: Conditionally submit an order
    if signal == "bullish" and position is None:
        logger.info(f"Bullish crossover for {symbol}. Submitting buy order.")
        submit_crypto_market_order(symbol, qty, OrderSide.BUY)

    elif signal == "bearish" and position is not None:
        held_qty = float(position.qty)
        logger.info(f"Bearish crossover for {symbol}. Submitting sell order for {held_qty}.")
        submit_crypto_market_order(symbol, held_qty, OrderSide.SELL)

    else:
        logger.info(f"No actionable signal for {symbol}. Signal: {signal}")

What this code does: The `run_sma_crossover_strategy` function runs the full workflow in sequence: data fetching, signal computation, position check, and conditional order submission. Logging statements record each step for review.

Limitations of this example:

• It does not include position sizing, stop-loss levels, or take-profit logic
• It runs once and exits; a production system would require scheduling (e.g., a time-based loop, cron, or cloud function)
• It uses daily bars; intraday strategies require different data intervals and additional considerations around latency and signal frequency
• Market orders may experience slippage, particularly during high-volatility periods common in crypto markets
• This example does not account for API rate limits, network errors, or exchange-level disruptions
• This example does not account for crypto trading fees, which may affect net returns

Step 6: Stream Real-Time Crypto Data

For strategies that require faster signal evaluation than daily bars allow, Alpaca's WebSocket-based streaming endpoint can help ingest live trade and quote data.

Subscribing to Real-Time Crypto Bars

from alpaca.data.live.crypto import CryptoDataStream

def on_bar(bar: object) -> None:
    """
    Callback invoked when a new crypto bar is received.

    Args:
        bar: The incoming bar data object.
    """
    print(f"New bar received: {bar}")

def start_crypto_stream(symbol: str = "BTC/USD") -> None:
    """
    Start a WebSocket stream for real-time crypto bars.

    Args:
        symbol: The crypto pair to subscribe to.
    """
    stream = CryptoDataStream(
        api_key=ALPACA_API_KEY,
        secret_key=ALPACA_SECRET_KEY
    )
    stream.subscribe_bars(on_bar, symbol)
    stream.run()

What this code does: It opens a persistent WebSocket connection and invokes `on_bar` each time a new bar is published for the subscribed symbol.

Why use streaming: For strategies that evaluate signals at short intervals (e.g., every minute), polling REST endpoints may introduce latency and rate limit concerns. Streaming can help reduce the gap between price events and signal evaluation.

When to use this: In bots designed to operate on intraday timeframes or that require near-real-time data ingestion.

Step 7: Log and Monitor

For bots that run autonomously, logging can be important for debugging and performance review.

import logging

def configure_logger(name: str = "crypto_bot") -> logging.Logger:
    """
    Configure and return a logger with timestamp and level formatting.

    Args:
        name: Logger name used to identify log source.

    Returns:
        A configured Logger instance.
    """
    logging.basicConfig(
        level=logging.INFO,
        format="%(asctime)s %(name)s %(levelname)s %(message)s"
    )
    return logging.getLogger(name)

What this code does: The `configure_logger` function configures Python's built-in `logging` module with timestamp and level prefix formatting.

Why structured logging matters: Without logs, it can be difficult to determine after the fact whether a signal fired, whether an order was submitted, or what error caused a bot to stop. Logs can also support auditing and post-trade review.

When to use this: Initialize the logger at the top of your main script. Call `logger.info()`, `logger.warning()`, and `logger.error()` throughout your strategy functions.

Consider logging:

• Signal values at each evaluation cycle
• Order submission confirmations and fill details
• Exception traces and API error codes
• Position snapshots before and after order submission

Additional Considerations

Combining SMA with Other Signals

An SMA crossover used in isolation may generate signals that do not correspond to sustained price moves. Some traders combine SMA signals with additional filters that may help reduce false positives:

• RSI (Relative Strength Index): Used by some traders to filter signals when RSI indicates potentially overbought or oversold conditions. See our resource on building a Free RSI and MACD Trading Bot with ChatGPT and Alpaca for an example of combining indicators
• Volume confirmation: Requiring above-average volume during a crossover may help filter signals in low-liquidity conditions
• Centerline confirmation: Some traders require that the shorter SMA remain above a longer baseline before acting on a crossover

No combination of indicators can fully address signal lag, and accuracy cannot be assured.

Selecting Timeframes

The (10, 30) SMA parameters used in this guide are illustrative defaults for daily bars. When applying SMA logic to other timeframes:

• Shorter bars (1-minute, 5-minute, hourly): May produce more frequent crossovers and potentially more false signals in choppy conditions
• Longer bars (weekly): May produce fewer signals; some traders adjust SMA periods proportionally when changing timeframes

Alpaca's Market Data API supports `TimeFrame.Minute`, `TimeFrame.Hour`, `TimeFrame.Day`, and TimeFrame.Week. See the Historical Crypto Data documentation for timeframe options applicable to crypto bars.

Paper Trading Before Any Live Deployment

Alpaca's paper trading environment simulates order execution using real market data without involving real capital. Paper trading can help:

• Verify that code executes without errors
• Observe how the strategy behaves during live market conditions
• Identify edge cases before considering any transition to a funded account

Simulated results from paper trading may not reflect live trading conditions, including slippage, partial fills, and real-time liquidity. For a detailed comparison, see Paper Trading vs. Live Trading: A Data-Backed Guide.

Risk Considerations

All trading strategies, including those using automated signal logic and crypto-specific workflows, carry risk. Some risks specific to this context include:

• Volatility: Cryptocurrency markets are subject to rapid and significant price changes. Automated bots can execute orders quickly, which may amplify losses when market conditions shift suddenly
• False signals: SMA crossovers may produce signals that do not lead to sustained directional moves, particularly in sideways markets
• Execution risk: Market orders may fill at prices that differ from the price at signal detection, especially during high-volatility periods
• Trading fees: Crypto trades on Alpaca incur maker/taker fees² that can affect net performance, particularly for strategies that trade frequently
• Continuous operation: Crypto markets run 24 hours a day, seven days a week. Bots require ongoing monitoring and error handling to manage unexpected shutdowns, API timeouts, or connectivity issues
• Code errors: Logic errors in bot code execute without hesitation. Thorough testing in a paper trading environment can help identify issues before live deployment is considered
• Data reliability: Incorrect or delayed data can lead to signals that do not reflect actual market conditions

There is always the potential of losing money when trading cryptocurrencies.

Conclusion

With the data, signal, and order workflow in place, you can now fetch crypto bars, compute SMA crossovers, and submit paper trading orders through Alpaca's Trading API for a defined pair.

When you are ready, schedule the strategy loop, add position sizing and risk controls, and review logging and error handling before considering any live deployment.

If you would like to go deeper on indicators, data, or deployment patterns, explore the resources below.

References

1. Alpaca Crypto, Alpaca Markets, Accessed March 2026.
2. Crypto Spot Trading Fees, Alpaca Markets, Accessed March 2026.
3. Alpaca Account Signup, Alpaca Markets, Accessed March 2026.
4. Getting Started: Alpaca-py, Alpaca Markets, Accessed March 2026.
5. Alpaca API Documentation, Alpaca Markets, Accessed March 2026.
6. About Market Data API, Alpaca Markets, Accessed March 2026.
7. pandas.DataFrame.rolling, pandas, Accessed March 2026.
8. About Trading API, Alpaca Markets, Accessed March 2026.
9. Paper Trading, Alpaca Markets, Accessed March 2026.
10. Placing Orders, Alpaca Markets, Accessed March 2026.
11. How to Build a Free RSI and MACD Trading Bot with ChatGPT and Alpaca, Alpaca Markets, May 2025.
12. Historical Crypto Data, Alpaca Markets, Accessed March 2026.
13. Paper Trading vs. Live Trading: A Data-Backed Guide on When to Start Trading Real Money, Alpaca Markets, August 2025.
14. Automated Crypto Scalping in Python on Alpaca's Trading API, Alpaca Markets, August 2022.

The Paper Trading API is offered by AlpacaDB, Inc. and does not require real money or permit a user to transact in real securities in the market. Providing use of the Paper Trading API is not an offer or solicitation to buy or sell securities, securities derivative or futures products of any kind, or any type of trading or investment advice, recommendation or strategy, given or in any manner endorsed by AlpacaDB, Inc. or any AlpacaDB, Inc. affiliate and the information made available through the Paper Trading API is not an offer or solicitation of any kind in any jurisdiction where AlpacaDB, Inc. or any AlpacaDB, Inc. affiliate (collectively, “Alpaca”) is not authorized to do business.

Securities brokerage services are provided by Alpaca Securities LLC (dba "Alpaca Clearing"), member FINRA/SIPC, a wholly-owned subsidiary of AlpacaDB, Inc. Technology and services are offered by AlpacaDB, Inc.

Cryptocurrency services are made available by Alpaca Crypto LLC ("Alpaca Crypto"), a FinCEN registered money services business (NMLS # 2160858), and a wholly-owned subsidiary of AlpacaDB, Inc. Alpaca Crypto is not a member of SIPC or FINRA. Cryptocurrencies are not stocks and your cryptocurrency investments are not protected by either FDIC or SIPC. Please see the Disclosure Library for more information.

This is not an offer, solicitation of an offer, or advice to buy or sell securities or cryptocurrencies or open a brokerage account or cryptocurrency account in any jurisdiction where Alpaca Securities or Alpaca Crypto, respectively, are not registered or licensed, as applicable.