alpaca-trader-rs

An Alpaca Markets trading toolkit for Rust — ships as both an integratable library and a standalone TUI trading app.

• Library (alpaca_trader_rs crate): typed async REST client, shared domain types, and WebSocket streaming primitives — embed it in your own Rust application.
• App (alpaca-trader binary): a full interactive terminal dashboard built on the library, with live account data, positions, orders, watchlist management, and order entry.

Installing the App

From crates.io (recommended)

cargo install alpaca-trader-rs

This compiles and installs the alpaca-trader binary to ~/.cargo/bin/. Requires Rust 1.88+.

Pre-compiled binaries

Download the latest binary for your platform from the Releases page.

From source

git clone https://github.com/arunkumar-mourougappane/alpaca-trader-rs
cd alpaca-trader-rs
cargo build --release
# binary at: target/release/alpaca-trader

Credential Setup

The app resolves credentials in priority order (highest wins):

Option A — First run (interactive, recommended for desktop):

Just run the app. If no credentials are found, it prompts for your API key and secret, then offers to save them to the OS keychain (macOS Keychain, Windows Credential Store, or Linux keyutils).

alpaca-trader --paper   # prompted for paper keys on first run
alpaca-trader           # prompted for live keys on first run

Option B — .env file (recommended for development):

cp .env.example .env
# Edit .env and fill in your API keys — see docs/credentials-setup.md

Option C — Environment variables (CI / containers):

export ALPACA_API_KEY=your-key-id
export ALPACA_API_SECRET=your-secret-key
alpaca-trader --paper

See docs/credentials-setup.md for obtaining keys from the Alpaca dashboard.

Running

alpaca-trader           # live trading (real money — default)
alpaca-trader --paper   # paper trading (simulated funds)
alpaca-trader --dry-run # simulate order submissions (no real orders sent)

The header badge shows [PAPER] in cyan or [LIVE] in red at all times.

If you installed from source, use ./run.sh --paper / ./run.sh instead of alpaca-trader.

Managing Stored Credentials

alpaca-trader --reset paper   # remove paper keychain entries
alpaca-trader --reset live    # remove live keychain entries

Key Bindings

Full interaction spec (including mouse): docs/ui-mockups.md

Library Usage

Add to your Cargo.toml:

[dependencies]
alpaca-trader-rs = "0.5"
tokio = { version = "1", features = ["full"] }

Fetch account info

use alpaca_trader_rs::client::AlpacaClient;
use alpaca_trader_rs::config::AlpacaConfig;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    let config = AlpacaConfig::from_env()?;
    let client = AlpacaClient::new(config);

    let account = client.get_account().await?;
    println!("Equity:        ${}", account.equity);
    println!("Buying power:  ${}", account.buying_power);

    Ok(())
}

Place an order

use alpaca_trader_rs::types::{OrderRequest, OrderSide, OrderType, TimeInForce};

let order = client.submit_order(&OrderRequest {
    symbol: "AAPL".into(),
    qty: Some("10".into()),
    notional: None,
    side: OrderSide::Buy.as_str().into(),
    order_type: OrderType::Limit.as_str().into(),
    time_in_force: TimeInForce::Day.as_str().into(),
    limit_price: Some("185.00".into()),
}).await?;

println!("Order submitted: {}", order.id);

Manage watchlists

let summaries = client.list_watchlists().await?;
let wl = client.get_watchlist(&summaries[0].id).await?;

for asset in &wl.assets {
    println!("{} — {} ({})", asset.symbol, asset.name, asset.exchange);
}

client.add_to_watchlist(&wl.id, "NVDA").await?;
client.remove_from_watchlist(&wl.id, "TLRY").await?;

Public Library API

Crate Structure

alpaca-trader-rs/
├── src/
│   ├── lib.rs              # Library root — public API
│   ├── main.rs             # Binary entry point — TUI app
│   ├── credentials.rs      # Credential resolution: env vars → keychain → TTY prompt
│   ├── config.rs           # AlpacaConfig: env resolution, paper/live selection
│   ├── client.rs           # AlpacaClient: all REST methods
│   ├── types.rs            # Shared domain types (serde-deserializable)
│   ├── events.rs           # Event enum
│   ├── app.rs              # App state — TEA Model
│   ├── update.rs           # update(state, event) + key routing
│   ├── input/              # Per-panel keyboard input handlers
│   │   ├── mod.rs
│   │   ├── watchlist.rs
│   │   ├── positions.rs
│   │   ├── orders.rs
│   │   ├── modal.rs
│   │   └── search.rs
│   ├── handlers/
│   │   ├── input.rs        # crossterm EventStream → Event
│   │   └── rest.rs         # Periodic REST polling task
│   └── ui/
│       ├── mod.rs          # render(frame, app) + popup_area()
│       ├── dashboard.rs    # Header, tab bar, status bar
│       ├── account.rs      # Account panel + sparkline
│       ├── watchlist.rs    # Watchlist table + search
│       ├── positions.rs    # Positions table + totals
│       ├── orders.rs       # Orders table + sub-tabs
│       ├── modals.rs       # Order entry, detail, help, about, confirm modals
│       └── theme.rs        # Colours and styles
├── tests/
│   └── client_tests.rs     # AlpacaClient integration tests (wiremock)
├── docs/                   # Full documentation
├── .env.example            # Credential template
├── run.sh                  # Run script (--paper / --live)
├── Cargo.toml
├── LICENSE-MIT
├── LICENSE-APACHE
└── README.md

Environment Variables

Credentials are loaded from the environment (or a .env file via dotenvy). Only the variables for the active environment are used — the opposing set is ignored.

Unified pair (highest priority)

Per-environment variables

Features

Documentation

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for development guidelines and our CODE_OF_CONDUCT.md for community standards.

Licensing

Licensed under either of

• Apache License, Version 2.0 or http://www.apache.org/licenses/LICENSE-2.0
• MIT license or http://opensource.org/licenses/MIT

at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.