TypeScript icon, indicating that this package has built-in type declarations

    2.11.1 • Public • Published

    Alpaca Trade API JS

    npm version CircleCI

    Node.js library for Alpaca Trade API.

    API Documentation

    The REST API documentation can be found in https://docs.alpaca.markets. For detailed information about an endpoint, please consult the REST API docs. Documentation specific to this library can be found below.


    We introduced Typescript support recently, which allows you to use strongly typed data structures and better IDE experience if you are using it.


    npm install --save @alpacahq/alpaca-trade-api

    Runtime Dependencies

    • Node.js v14.x or newer
    • npm version 6 and above


    Import the module first.

    const Alpaca = require('@alpacahq/alpaca-trade-api')

    Instantiate the API with config options, obtained from the dashboard at app.alpaca.markets.

    const alpaca = new Alpaca({
      keyId: 'AKFZXJH121U18SHHDRFO',
      secretKey: 'pnq4YHlpMF3LhfLyOvmdfLmlz6BnASrTPQIASeiU',
      paper: true,

    Note: keyId and secretKey may also be specified by setting the APCA_API_KEY_ID and APCA_API_SECRET_KEY environment variables, respectively. Also, rather than specifying paper, you may set APCA_API_BASE_URL as an environment variable to direct your API calls to the paper trading API.

    Call methods, which will return a promise.

    alpaca.getAccount().then((account) => {
      console.log('Current Account:', account)

    The websocket api is a good way to watch and react to the market we have 2 types of websockets:

    • data websocket: get updates to data equities
    • account/trade websocket: get updates on your account

    please refer to this example code to see how to use the websockets.

    Data WS

    The Alapca websocket service now supports V2. Make sure you update your old sample code accordingly.
    You could use it even if you don't have a funded account.


    As a general rule, required method parameters are passed as plain function arguments, and the final parameter is an object containing any optional parameters to the method.

    Account API

    Get Account

    Calls GET /account and returns the current account.

    getAccount() => Promise<Account>

    Account Configurations API

    Get Account Configurations

    Calls GET /account/configurations and returns the current account configurations.

    getAccountConfigurations() => Promise<AccountConfigurations>

    Update Account Configurations

    Calls PATCH /account/configurations to update the account configurations, and returns the updated configurations.

    updateAccountConfigurations(AccountConfigurations) => Promise<AccountConfigurations>

    Get Account Activities

    Calls GET /account/activities and returns account actvities.

      activityTypes: string | string[], // Any valid activity type
      until: Date,
      after: Date,
      direction: string,
      date: Date,
      pageSize: number,
      pageToken: string
    }) => Promise<AccountActivity[]>

    Portfolio History API

    Get Portfolio History

    Calls GET /account/portfolio/history and returns portfolio history.

      date_start: Date,
      date_end: Date,
      period: '1M' | '3M' | '6M' | '1A' | 'all' | 'intraday',
      timeframe: '1Min' | '5Min' | '15Min' | '1H' | '1D',
      extended_hours: Boolean
    }) => Promise<PortfolioHistory>

    Orders API

    Create Order

    Calls POST /orders and creates a new order.

      symbol: string, // any valid ticker symbol
      qty: number, 
      notional: number, // qty or notional required, not both
      side: 'buy' | 'sell',
      type: 'market' | 'limit' | 'stop' | 'stop_limit' | 'trailing_stop',
      time_in_force: 'day' | 'gtc' | 'opg' | 'ioc',
      limit_price: number, // optional,
      stop_price: number, // optional,
      client_order_id: string, // optional,
      extended_hours: boolean, // optional,
      order_class: string, // optional,
      take_profit: object, // optional,
      stop_loss: object, // optional,
      trail_price: string, // optional,
      trail_percent: string // optional,
    }) => Promise<Order>

    Get Orders

    Calls GET /orders and returns a list of orders.

      status: 'open' | 'closed' | 'all',
      after: Date,
      until: Date,
      limit: number,
      direction: 'asc' | 'desc'
    }) => Promise<Order[]>

    Get Order by ID

    Calls GET /orders/{id} and returns an order.

    getOrder(uuid) => Promise<Order>

    Get Order by Client ID

    Calls GET /orders:by_client_order_id and returns an order by client_order_id. You can set client_order_id upon order creation to more easily keep track of your orders.

    getOrderByClientOrderId(string) => Promise<Order>

    Update Order by ID

    Calls PATCH /orders/{id} and updates an existing open order. The updated order will have a new ID.

    replaceOrder(uuid) => Promise<Order>

    Cancel Order

    Calls DELETE /orders/{id} and deletes an order.

    cancelOrder(uuid) => Promise

    Cancel all Orders

    Calls DELETE /orders and deletes all open orders.

    cancelAllOrders() => Promise

    Positions API

    Get Position

    Calls GET /positions/{symbol} and returns a position.

    getPosition(symbol) => Promise<Position>

    Get All Positions

    Calls GET /positions and returns all positions.

    getPositions() => Promise<Position[]>

    Close a Position

    Calls DELETE /positions/{symbol} and liquidates your position in the given symbol.

    closePosition(symbol) => Promise

    Close all Positions

    Calls DELETE /positions and liquidates all open positions.

    closeAllPositions() => Promise

    Assets API

    Get All Assets

    Calls GET /assets and returns assets matching your parameters.

      status: 'active' | 'inactive',
      asset_class: string
    }) => Promise<Asset[]>

    Get information about an asset

    Calls GET /assets/{symbol} and returns an asset entity.

    getAsset(symbol) => Promise<Asset>

    Calendar API

    Calls GET /calendar and returns the market calendar.

    getCalendar({ start: Date, end: Date }) => Promise<Calendar[]>

    Watchlist API

    available methods for you to use:

    module.exports = {

    Get All Watchlists

    this.alpaca.getWatchlists().then((response) => {

    Get Specific Watchlist

     // xxxx.. are the watchlist id you get on creation or with get all
     this.alpaca.getWatchlist('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx').then((response) => {

    Add a Watchlist

    this.alpaca.addWatchlist("myWatchList", []).then((response) => {

    Add to Watchlist

    this.alpaca.addToWatchlist('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx', "AAPL").then((response) => {

    Update a Watchlist

    this.alpaca.updateWatchlist("myWatchList", ["AAPL", "GOOG"]).then((response) => {

    Delete a Watchlist

    this.alpaca.deleteWatchlist('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx').then((response) => {

    Delete from Watchlist

    this.alpaca.deleteFromWatchlist('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx', "AAPL").then((response) => {

    Data API

    Get Bars

        limit: number,
        start: date isoformat string yyyy-mm-ddThh:MM:ss-04:00,
        end: date isoformat string yyyy-mm-ddThh:MM:ss-04:00,
        timeframe: "1Min" | "1Hour" | "1Day"
    ) => Promise<BarsObject>
    let resp = this.alpaca.getBarsV2(
            start: "2021-02-01",
            end: "2021-02-10",
            limit: 2,
            timeframe: "1Day",
            adjustment: "all",
    const bars = [];
    for await (let b of resp) {

    note: to get the date of response samples you could do this console.log(new Date(resp['AAPL'][0].startEpochTime*1000))

    Last trade

      symbol: string)
    ) => Promise<LastTradeObject>
    this.alpaca.lastTrade('AAPL').then((response) => {

    Last quote

      symbol: string)
    ) => Promise<LastQuoteObject>
    this.alpaca.lastQuote('AAPL').then((response) => {


    You can use data websocket with or without a funded account.

    Working with websocket

    • The websocket is created when you creating the Alpaca instance
    • const websocket = alpaca.data_stream_v2: Get the websocket client instance.
    • websocket.connect(): Connect to the Alpaca server using websocket.
    • client.onConnect(function() {}): all the following code will be executed after the user authentication. You can also subscribe and unsubscribe for data outside this function.
    • websocket.subscribeForTrades(["symbol"]): Subscribe for trades data for the given symbol(s). You can do the same with quotes, bars, dailyBars, statuses and lulds.
    • websocket.onStockTrade(function(trade) {}): Get the data and process it inside this function.
    • websocket.unsubscribeFromTrades(["symbol"]): Unsunscribe from symbol(s).
    • websocket.onDisconnect(function() {}) and websocket.disconnect(): the function inside the onDisconnect will run when you disconnect, then closes the connection between the client and server.

    • const cryptoWebsocket = alpaca.crypto_stream_v2: Get the crypto websocket client instance.
    • cryptoWebsocket.subscribeForTrades(["symbol"]), cryptoWebsocket.unsubscribeFromTrades(["symbol"]), cryptoWebsocket.onCryptoTrade(function(cryptoTrade) {}) Working as the examples above.
    • cryptoWebsocket.onDisconnect(function() {}) and cryptoWebsocket.disconnect(): Same as above.


    npm i @alpacahq/alpaca-trade-api

    DownloadsWeekly Downloads






    Unpacked Size

    213 kB

    Total Files


    Last publish


    • chemicalrocketeer
    • oss.alpaca.markets
    • ttt733