Tutorial de Python de la API de Alpaca Markets

Este tutorial enseña cómo llamar al API de mercados de alpaca en Python usando el oficial Cliente Alpaca-py y la función de solicitud de Python.

La API de Alpaca proporciona una amplia documentación para acceder a su punto final. Además, algunos artículos en Internet demuestran cómo llamar a la API de Alpaca en Python.

Sin embargo, encuentro que la documentación oficial carece de ejemplos del mundo real. Además, la mayoría de los artículos existentes apuntan a la obsoleta Alpaca. trade Biblioteca API python, que ha sido reemplazada por el nuevo cliente Alpaca-py orientado a objetos.

En este artículo, explicaré, con la ayuda de ejemplos del mundo real, cómo llamar a la API de Alpaca usando el último cliente Python de Alpaca-py. Verá cómo usar Alpaca-py para extraer datos históricos a través de API REST y datos de transmisión en tiempo real a través de Websockets.

¿Qué es Alpaca Markets?

Alpaca Markets es una inteligente trading plataforma que permite a los desarrolladores, inversores y comerciantes ver los valores de las acciones, procesar la información del mercado de valores y ejecutar trading operaciones.

Alpaca’s se fundó en 2015 y su sede se encuentra en San Mateo, California.

¿Qué es la API de Alpaca Markets?

La API de Alpaca Markets ofrece servicios de API REST para acceder a los datos de Alpaca Markets en código. Los comerciantes, inversores, desarrolladores e investigadores pueden aprovechar la API de Alpaca para desarrollar software financiero personalizado, algorítmico trading aplicaciones, modelos estadísticos de previsión de existencias, etc.

Pros y contras de los mercados de alpaca

Los siguientes son algunos de los pros y los contras de Alcapa Markets:

ventajas

  • Alpaca no cobra ninguna comisión por la compra y venta de acciones y ETF.
  • Alpaca tiene una API gratuita que le permite desarrollar aplicaciones financieras personalizadas.
  • Fantásticas herramientas gráficas y de interfaz gráfica de usuario.
  • Papel trading le permite simular un natural trading ambiente.
  • permite trading para residentes de EE. UU. y no estadounidenses.

Contras

  • Alpaca solo es compatible con los mercados bursátiles de EE. UU.
  • Los usuarios informan de una mala atención al cliente.
  • Requerir un mínimo de $ 30,000 para empresas fuera de los EE. UU. trading cuentas

Planes de precios API de Alpaca Markets

Alpaca API tiene una suscripción gratuita e ilimitada, que cuesta $ 99 por mes. Ver Planes de suscripción de Alpaca Markets para más detalles.Planes de Precios de Alpaca Markets

Cómo comenzar con la API de Alpaca Markets en Python

Utilizará la suscripción gratuita de Alpaca Markets para los códigos de este tutorial. Para hacerlo, debes registrarte con Mercados de Alpaca.como se muestra en las siguientes capturas de pantalla.Página de registro de Alpaca MarketsAlpaca enviará un correo electrónico de verificación a su dirección de correo electrónico. Active su cuenta de Alpaca desde su correo electrónico e inicie sesión en Alpaca Markets. Selecciona la opción “Cuenta Individual” y completa el formulario que aparece.Selección de cuenta de Alpaca Markets

Necesitará una clave de API y una clave secreta de API para acceder a la API de Alpaca. Para ello, acceda a su tablero, y haga clic en “Generar nueva clave” en el lado derecho de su tablero. Pantalla de generación de clave API de Alpaca Markets

Guarde su clave de API y su secreto de API en un lugar seguro. Para este tutorial, guardé estos valores en variables de entorno del sistema.

Ejemplo simple de obtención de datos mediante la API de Alpaca Markets en Python

Tiene un par de opciones para hacer llamadas a la API REST de Alpaca:

  • Según el idioma de su elección, puede aprovechar uno de los cinco clientes oficiales de la API de Alpaca Markets. Para Python, puede usar el Alpaca-py Cliente de Python para llamar a los puntos finales de la API de Alpaca. La biblioteca Alpaca-py solo admite la versión 3.7 de Python y superior.
  • La otra opción es usar la función de solicitud de Python para acceder a la API de Alpaca. Si la velocidad y la flexibilidad son sus objetivos principales, le recomiendo utilizar la función de solicitud. La biblioteca cliente de Alpaca-py es un buen punto de entrada a la API de Alpaca.
  • En este tutorial, utilizará la biblioteca Alpaca-py.

    Ejemplo de la biblioteca Python de la API de Alpaca Markets

    Cuatro entidades principales le permiten acceder a cualquier función de punto final en la API de Alpaca utilizando el cliente Alpaca-py.

  • Las clases de clientes, por ejemplo, TradingClient, StockHistoricalDataClient, BrokerClient, etc.
  • Las clases de solicitud, por ejemplo, GetAssetsRequest, StockLatestQuoteRequest, etc.
  • Las enumeraciones, por ejemplo, AssetClass, OrderSide, ActivityType, etc.
  • Las clases de modelo, por ejemplo, Cuenta, Activo, Pedido, etc.
  • Debe inicializar una de las clases de cliente para llamar a una función API. Según el punto final al que desee acceder, es posible que deba pasar una o más clases de solicitud como parámetro a los métodos de clase de cliente. Las enumeraciones y los modelos asignan valores a uno o más atributos de clase de solicitud.

    El siguiente script instala la biblioteca cliente de Alpaca-py.

    # install the library with the following command
    # pip install alpaca-py # prepend a ! for Jupyter notebook

    Veamos un ejemplo básico de cómo puede acceder a todos los activos de acciones utilizando el método get_all_assets() de la clase TradingClient.

    El siguiente script define las variables que almacenan la clave de API y la clave secreta de API de las variables de entorno.

    import os
    import pandas as pd
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']

    El siguiente script crea un objeto de la clase TradingClient. Debe pasar su clave de API y su secreto al constructor de la clase TradingClient.

    from alpaca.trading.client import TradingClient
    from alpaca.trading.requests import GetAssetsRequest
    from alpaca.trading.enums import AssetClass
    
    trading_client = TradingClient(api_key, api_secret, paper=True)

    A continuación, debe definir los parámetros de búsqueda de los activos que desea devolver utilizando la clase GetAssetRequest. La enumeración AssetClass.US_EQUITY especifica que queremos devolver activos de renta variable estadounidenses. Para obtener una lista de criptoactivos, puede usar la enumeración AssetClass.CRYPTO.

    El paso final es pasar el objeto de la clase GetAssetRequest al método get_all_assets(), como se muestra en el siguiente ejemplo.

    search_params = GetAssetsRequest(asset_class=AssetClass.US_EQUITY)
    assets = trading_client.get_all_assets(search_params)
    assets

    Alpaca API Obtenga todos los activos de renta variable de EE. UU. Salida

    El resultado anterior contiene una lista de activos donde cada elemento de la lista es un objeto de la alpaca.trading.modelos.Clase de activo.

    alpaca.trading.models.Asset

    Para una mejor vista, puede convertir la lista de objetos de clase de activos en una lista de diccionarios que luego puede convertir en marcos de datos de Pandas:

    import pandas as pd
    assets_dict = [dict(item) for item in assets]
    
    df = pd.DataFrame.from_records(assets_dict)
    df.head(10)

    Alpaca API Obtenga todos los activos de acciones de EE. UU. DataFrame

    Ejemplo de función de solicitud de API de Alpaca Markets

    Puede usar la función de solicitud() de Python para llamar a la API de Alpaca, como cualquier otra función de la API REST. La función request() devuelve un objeto JSON, que se puede analizar más para recuperar los datos necesarios. Se recomienda este enfoque si la velocidad y la flexibilidad son sus principales preocupaciones.

    El siguiente ejemplo muestra cómo obtener una lista de todos los activos usando la API de Alpaca punto final del activo.

    import requests
    from requests.exceptions import ConnectionError, Timeout, TooManyRedirects
    import json
    import pandas as pd
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    url = 'https://paper-api.alpaca.markets'
    api_call = '/v2/assets'
    
    headers = {'content-type': 'application/json', 
               'Apca-Api-Key-Id': api_key, 
               'Apca-Api-Secret-Key': api_secret}
    
    response = requests.get(url + api_call, headers=headers)
    response = json.loads(response.text)
    assets = [dict(item) for item in response]
    df = pd.DataFrame.from_records(assets)
    df.head()

    Marco de datos de activos del método de solicitud de la API de Alpaca

    ¿Cuáles son los puntos finales de la API de Alpaca Markets?

    El cliente de Alpaca-Py agrupa los extremos de la API de Alpaca en tres grupos:

  • API de datos de mercado: permite recuperar datos históricos y en vivo para acciones y criptomonedas.
  • Trading API: brinda servicios para comprar y vender acciones y criptomonedas, crear listas de seguimiento, obtener información de activos, etc.
  • Broker API: permite crear cuentas de corretaje en nombre de sus usuarios.
  • API de datos de mercado

    La API de Market Data tiene cuatro clases principales:

  • StockHistoricalDataClient: contiene métodos que devuelven datos históricos de acciones
  • StockDataStream: proporciona puntos finales para acceder a datos de stock en vivo
  • CryptoHistoricalDataClient: consiste en funcionalidades que devuelven criptodatos históricos
  • CryptoDataStream: devuelve datos criptográficos en vivo
  • Puede usar el objeto python apropiado de la lista anterior según las funciones de la API a las que desee acceder.

    Obtenga datos históricos del mercado de valores con Alpaca

    No necesita una clave de API y un secreto para acceder a los puntos finales desde el StockHistoricalData clases de clientes. Sin embargo, para lograr límites de acceso a datos más altos, le recomiendo que use la clave de API y los secretos de API para acceder a todos los puntos finales de la API de Alpaca.

    Obtenga datos históricos de la barra de acciones

    Puede usar el método get_stock_bars() de la clase StockHistoricalDataClient para obtener valores históricos de acciones de OHLC. La lista de símbolos bursátiles, las fechas de inicio y la duración del tiempo se pasan a la clase StockBarsRequest, que posteriormente parametriza el método get_stock_bars().

    from alpaca.data.timeframe import TimeFrame
    from alpaca.data.requests import StockBarsRequest
    from alpaca.data.historical import StockHistoricalDataClient
    
    import os
    import pandas as pd
    
    
    client = StockHistoricalDataClient(api_key, api_secret)
    request_params = StockBarsRequest(
                            symbol_or_symbols=["AAPL", "TSLA"],
                            timeframe=TimeFrame.Day,
                            start="2022-10-04 00:00:00",
                            end="2022-10-06 00:00:00"
                     )
    bars = client.get_stock_bars(request_params)
    bars_df = bars.df
    bars_df

    Obtenga el último precio de venta de existencias

    El método get_stock_latest_quote() devuelve el último precio solicitado de una cotización. Debe pasar el símbolo de cotización a la clase StockLatestQuotesRequest, que se pasa al método get_stock_latest_quote().

    from alpaca.data.historical import StockHistoricalDataClient
    from alpaca.data.requests import StockLatestQuoteRequest
    from alpaca.data.timeframe import TimeFrame
    
    import os
    import pandas as pd
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # keys required
    client = StockHistoricalDataClient(api_key , api_secret)
    
    request_params = StockLatestQuoteRequest(symbol_or_symbols=["TLT", "GLD"],
                                             timeframe=TimeFrame.Day
                                            )
    
    quotes = client.get_stock_latest_quote(request_params)
    
    pd.DataFrame(quotes)

    API de Alpaca Obtener el último marco de datos de precios solicitados de accionesMarket API proporciona interfaces de transmisión de datos que puede aprovechar para obtener datos en tiempo real. Para hacerlo, debe crear una función asíncrona que se llame periódicamente. A continuación, debe crear un objeto de la StockDataStream clase y el método que solicita datos en tiempo real de la API de Alpaca.

    La función asíncrona se pasa al método de clase StockDataStream que obtiene los datos en tiempo real.

    Por ejemplo, la siguiente secuencia de comandos ejecuta la función bars_data_handler() cada minuto, que imprime los datos devueltos por el método subscribe_bars() en llamadas posteriores a la API.

    import nest_asyncio
    nest_asyncio.apply()
    
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    from alpaca.data.live import StockDataStream
    
    wss_client = StockDataStream(api_key, api_secret)
    
    # async handler
    async def bars_data_handler(data):
        # real-time data will be displayed here
        # as it arrives
        print(data)
        print("===")
    
    wss_client.subscribe_bars(bars_data_handler, "GLD")
    
    wss_client.run()

    Obtenga datos históricos del mercado criptográfico de Alpaca

    Él CryptoHistoricalDataClient Los métodos de clase devuelven datos históricos de criptomonedas. El proceso es muy similar a la recuperación de datos históricos de acciones. Debe crear un objeto de la clase CryptoHistoricalDataClient y llamar al método que devuelve datos históricos. El método está parametrizado por el objeto de solicitud, que especifica filtros para recuperar datos históricos.

    Obtenga datos históricos de la barra criptográfica

    El siguiente script llama al método get_crypto_bars() para recuperar valores históricos de OHLC en USD para Bitcoin y Etéreo.

    from alpaca.data.historical import CryptoHistoricalDataClient
    from alpaca.data.requests import CryptoBarsRequest
    from alpaca.data.timeframe import TimeFrame
    
    # no keys required for crypto data
    client = CryptoHistoricalDataClient()
    
    request_params = CryptoBarsRequest(
                            symbol_or_symbols=["BTC/USD", "ETH/USD"],
                            timeframe=TimeFrame.Day,
                            start="2022-10-04 00:00:00",
                            end="2022-10-06 00:00:00")
    
    bars = client.get_crypto_bars(request_params)
    
    bars.df

    Obtenga el último precio de venta de criptoactivos

    Del mismo modo, puede obtener los últimos precios solicitados para cualquier criptomoneda utilizando el método get_crypto_latest_quote() de la clase CryptoHistoricalDataClient.

    from alpaca.data.historical import CryptoHistoricalDataClient
    from alpaca.data.requests import CryptoLatestQuoteRequest
    from alpaca.data.timeframe import TimeFrame
    
    import os
    import pandas as pd
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # keys not required
    client = CryptoHistoricalDataClient()
    
    request_params = CryptoLatestQuoteRequest(symbol_or_symbols=["BTC/USD", "ETH/USD"],
                                             timeframe=TimeFrame.Day
                                            )
    
    quotes = client.get_crypto_latest_quote(request_params)
    
    pd.DataFrame(quotes)

    Alpaca API Último marco de datos de precio de venta de criptomonedas

    Obtenga datos de criptomercado en tiempo real con Alpaca

    Finalmente, como vio con los datos de precios de acciones en tiempo real, puede recuperar datos de criptomonedas en tiempo real utilizando métodos de clase CryptoDataStream. El resto del proceso es similar a obtener g datos de precios de acciones en tiempo real.

    El siguiente script usa el método subscribe_bars() de la clase CryptoDataStream para recuperar valores OHLC en tiempo real para Ethereum.

    import nest_asyncio
    nest_asyncio.apply()
    
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    from alpaca.data.live import CryptoDataStream
    
    wsc_client = CryptoDataStream(api_key, api_secret)
    
    # async handler
    async def bar_data_handler(data):
        # real-time data will be displayed here after every minute
        print(data)
        print("====")
    
    wsc_client.subscribe_bars(bar_data_handler,  "ETH/USD")
    
    wsc_client.run()

    Marco de datos de flujo de datos criptográficos de API de Alpaca

    Para obtener más información sobre las otras funciones de Market API, consulte el sitio web oficial Referencia de datos de mercado.

    Trading API

    Trading Los puntos finales de la API le permiten ejecutar varios trading operaciones, por ejemplo, compra y venta de acciones y criptomonedas, visualización de información de pedidos y posiciones de cuenta.

    Él Cliente comercial clase de la Trading La API proporciona los métodos que necesita para realizar trading operaciones en Alpaca utilizando la API de Alpaca.

    obtener alpaca Trading detalles de la cuenta

    Una vez que te registras para un papel de Alpaca trading o vivir trading cuenta, puede recuperar la información de su cuenta en Python utilizando el método get_account() de la clase TradingClient. Aquí hay un ejemplo.

    from alpaca.trading.client import TradingClient
    import os
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # paper=True enables paper trading
    trading_client = TradingClient(api_key, api_secret, paper=True)
    account = trading_client.get_account()
    account

    API de alpaca Trading Detalle de la cuenta Salida JSON

    Obtenga una lista de todos los activos de alpaca

    El método get_all_assets() de la clase TradingClient devuelve una lista de todas las acciones o criptoactivos de Alpaca Markets. Por ejemplo, podría estar interesado en encontrar acciones o símbolos negociables. Puede obtener esta información de la propiedad negociable de la información devuelta por el método get_all_assets().

    Obtener activos de stock de alpaca
    Para obtener activos de acciones de Alpaca Markets, debe pasar la enumeración AssetClass.US_EQUITY al objeto de clase GetAssetsRequest.

    from alpaca.trading.client import TradingClient
    from alpaca.trading.requests import GetAssetsRequest
    from alpaca.trading.enums import AssetClass
    import pandas as pd
    
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    search_params = GetAssetsRequest(asset_class=AssetClass.US_EQUITY)
    
    assets = trading_client.get_all_assets(search_params)
    
    assets_dict = [dict(item) for item in assets]
    
    
    df = pd.DataFrame.from_records(assets_dict)
    df.head()

    Alpaca API Obtener marco de datos de activos de stock

    Obtenga activos criptográficos de Alpaca

    Por el contrario, para recuperar criptoactivos, debe pasar AssetClass.CRYPTO al atributo asset_class de la clase GetAssetsRequest, como se muestra en el siguiente script:

    from alpaca.trading.client import TradingClient
    from alpaca.trading.requests import GetAssetsRequest
    from alpaca.trading.enums import AssetClass
    
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    search_params = GetAssetsRequest(asset_class=AssetClass.CRYPTO)
    
    assets = trading_client.get_all_assets(search_params)
    
    assets_dict = [dict(item) for item in assets]
    
    
    df = pd.DataFrame.from_records(assets_dict)
    df.head()

    Alpaca API Obtener marco de datos de criptoactivos

    Puede obtener información, por ejemplo, si un activo se puede vender en corto, activo, negociable, etc., usando el método get_asset(). El siguiente script devuelve información de activos para ETH/USD.

    from alpaca.trading.client import TradingClient
    from alpaca.trading.requests import GetAssetsRequest
    from alpaca.trading.enums import AssetClass
    
    trading_client = TradingClient(api_key, api_secret, paper=True)
    asset = trading_client.get_asset("ETH/USD")
    asset

    Alpaca API Python Client Obtener información de activos de Ethereum DataFrame

    Compre o venda un activo con Alpaca Markets

    El método submit_order() de la clase TradingClient le permite comprar o vender un activo. Debe pasar el objeto OrderRequest al método submit_order(). El objeto OrderRequest está parametrizado por enumeraciones Lado del pedido, tiempo en vigory Tipo de orden.

    Crear una orden para comprar un activo

    Para crear una orden para comprar un activo, debe pasar la enumeración OrderSide.BUY al atributo lateral de la clase OrderRequest.
    El siguiente ejemplo demuestra cómo comprar 2 activos ETH/USD.

    from alpaca.trading.client import TradingClient
    from alpaca.trading.requests import OrderRequest
    from alpaca.trading.enums import OrderSide, TimeInForce, OrderType
    
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    order_request = OrderRequest(
                       symbol="ETH/USD",
                       qty = 2,
                       side = OrderSide.BUY,
                       type = OrderType.MARKET,
                       time_in_force = TimeInForce.GTC
                       )
    
    new_order  = trading_client.submit_order(
                   order_data=order_request
                  )
    dict(new_order)

    Alpaca API Python Cliente Enviar pedido Comprar ETHUSD Dict

    Crear una orden para vender un activo

    El proceso es el mismo para vender un activo excepto por lo siguiente:

  • Debe tener una cantidad suficiente de activos que desea vender. Por ejemplo, compró dos ETH/USD en el script anterior. Solo puedes vender menos o igual a 2 ETH/USD.
  • Debe pasar la enumeración OrderSide.SELL al atributo lateral.
  • Aquí hay un ejemplo de venta de un activo a través de Alpaca Trading API.

    from alpaca.trading.client import TradingClient
    from alpaca.trading.requests import OrderRequest
    from alpaca.trading.enums import OrderSide, TimeInForce, OrderType
    import time
    
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    order_request = OrderRequest(
                       symbol="ETH/USD",
                       qty = 0.5,
                       side = OrderSide.SELL,
                       type = OrderType.MARKET,
                       time_in_force = TimeInForce.GTC
                       )
    
    new_order  = trading_client.submit_order(
                   order_data=order_request
                  )
    dict(new_order)

    Alpaca API Python Cliente Enviar Oorder Setll ETHUSD Dict

    Obtener información de pedido de alpaca

    Puede obtener información sobre todas sus órdenes de compra o venta utilizando el método get_orders() de la clase TradingClient.

    En el resultado, verá los detalles del pedido, como la hora de creación del pedido, el tipo de pedido, el estado del pedido, etc.

    from alpaca.trading.client import TradingClient
    import pandas as pd
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # paper=True enables paper trading
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    all_orders = trading_client.get_orders()
    
    orders_dict = [dict(item) for item in all_orders]
    
    df = pd.DataFrame.from_records(orders_dict)
    df

    Alpaca API Python Cliente Obtener pedidos DataFrame

    from alpaca.trading.client import TradingClient
    import pandas as pd
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # paper=True enables paper trading
    trading_client = TradingClient(api_key, api_secret, paper=True)
    order = trading_client.get_order_by_id("f7b0af79-5b7e-42d9-bb45-76f59eb31279")
    order

    Alpaca API Cliente de Python Obtener orden por diccionario de ID

    obtener alpaca Trading Posiciones de activos

    Una posición de activo se refiere a la cantidad de un activo, el precio actual, la diferencia de precio por día, el valor de mercado, etc. El método get_all_positions() devuelve las posiciones de todos sus activos:

    from alpaca.trading.client import TradingClient
    import pandas as pd
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # paper=True enables paper trading
    trading_client = TradingClient(api_key, api_secret, paper=True)
    account_positions = trading_client.get_all_positions()
    positions_dict = [dict(item) for item in account_positions]
    
    df = pd.DataFrame.from_records(positions_dict)
    df.head()

    Alpaca API Python Cliente Obtener todas las posiciones DataFrame

    Cancelar un pedido de alpaca

    Si cambia de opinión en cualquier momento, puede cancelar un pedido ya realizado mediante el método cancel_order_by_id(). Debe pasar la identificación del pedido a este método.

    from alpaca.trading.client import TradingClient
    import pandas as pd
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # paper=True enables paper trading
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    order = trading_client.cancel_order_by_id('e002bc38-1064-4c2e-bc3f-4a29bb3fb2ad')

    Puede cancelar todos sus pedidos utilizando el método cancel_orders().

    from alpaca.trading.client import TradingClient
    import pandas as pd
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # paper=True enables paper trading
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    trading_client.cancel_orders()

    Cree una lista de seguimiento de alpacas para el seguimiento de activos

    Una lista de observación enumera las acciones que un trader pistas de potencial trading e inversiones. La principal diferencia entre una posición de activos es que usted posee los activos en las posiciones de activos, mientras que solo está interesado en los activos de la lista de seguimiento pero aún no los ha comprado.

    La API de Alpaca le permite crear listas de observación utilizando el método create_watchlist() de la clase TradingClient. Los atributos de una lista de vigilancia, por ejemplo, el nombre y el símbolo de la lista de vigilancia, se pasan al objeto CreateWatchlistRequest().

    from alpaca.trading.client import TradingClient
    from alpaca.trading.requests import CreateWatchlistRequest
    import pandas as pd
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # paper=True enables paper trading
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    watch_list_request = CreateWatchlistRequest(
                       name ="BTC WL3",
                       symbols=["BTC/USD"]
                       )
    
    watch_list  = trading_client.create_watchlist(
                   watchlist_data = watch_list_request
                  )
    dict(watch_list)

    Alpaca API Cliente de Python Crear dictado de lista de seguimiento

    Puede recuperar una lista de todas las listas de observación que ha creado usando el método get_all_watchlists():

    from alpaca.trading.client import TradingClient
    import pandas as pd
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # paper=True enables paper trading
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    get_all_watchlists = trading_client.get_watchlists()
    
    watch_lists = [dict(item) for item in get_all_watchlists]
    
    df = pd.DataFrame.from_records(watch_lists)
    df.head()

    Alpaca API Python Cliente Obtener listas de seguimiento DataFrame

    Recibe Anuncios Corporativos con Alpaca

    Puede obtener información sobre escisiones, fusiones y otros eventos corporativos relacionados con un activo mediante el método get_corporate_announcements().

    Debe pasar la lista de tipos de eventos, el intervalo de fechas de inicio y finalización y el símbolo de activo al objeto de clase GetCorporateAnnouncementsRequest, que luego se pasa al método get_coporate_announcements().

    Por ejemplo, el siguiente script busca eventos de fusión y dividendos para “ETH/USD” entre 2022-09-04 y 2022-10-06.

    from alpaca.trading.client import TradingClient
    from alpaca.trading.requests import GetCorporateAnnouncementsRequest
    from alpaca.trading.enums import CorporateActionType
    
    import pandas as pd
    from datetime import datetime
    
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # paper=True enables paper trading
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    
    request_params =  GetCorporateAnnouncementsRequest(
                            ca_types = [CorporateActionType.MERGER, CorporateActionType.DIVIDEND],
                            since = datetime.strptime('2022-09-04', '%Y-%m-%d').date(),
                            until = datetime.strptime('2022-10-06', '%Y-%m-%d').date(),
                            symbol = "ETH/USD"
                            
                       )
    
    corporate_announcements  = trading_client.get_corporate_annoucements(request_params)

    Cómo obtener el calendario de mercados de alpaca

    Puede obtener una lista de todos trading días desde la API de Alpaca usando el método get_calendar() del objeto de la clase TradingClient. Este método devuelve todo trading días a partir de 1970-01-02.

    from alpaca.trading.client import TradingClient
    from alpaca.trading.requests import GetCalendarRequest
    
    import pandas as pd
    from datetime import datetime
    
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # paper=True enables paper trading
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    
    trading_calendar  = trading_client.get_calendar()
    
    trading_cal = [dict(item) for item in trading_calendar]
    
    df = pd.DataFrame.from_records(trading_cal)
    df.head()

    Alpaca API Python Cliente Obtener Calendario DataFrame

    También puede obtener días de marketing entre dos días utilizando el método get_calendar(). Sin embargo, para hacerlo, debe pasar las fechas de inicio y finalización a la clase GetCalendarRequest, que posteriormente parametriza get_calendar().

    from alpaca.trading.client import TradingClient
    from alpaca.trading.requests import GetCalendarRequest
    
    import pandas as pd
    from datetime import datetime
    
    import os
    
    api_key = os.environ['AP-Key']
    api_secret = os.environ['AP-Secret']
    
    # paper=True enables paper trading
    trading_client = TradingClient(api_key, api_secret, paper=True)
    
    
    request_params =  GetCalendarRequest(
                            start = datetime.strptime('2022-09-04', '%Y-%m-%d').date(),
                            end = datetime.strptime('2022-10-06', '%Y-%m-%d').date(),
                            
                       )
    
    trading_calendar  = trading_client.get_calendar(request_params)
    
    trading_cal = [dict(item) for item in trading_calendar]
    
    df = pd.DataFrame.from_records(trading_cal)
    df.head()

    Alpaca API Cliente de Python Obtener marco de datos de ventana de calendario

    Él Trading API ofrece varios otros puntos finales que puede aprovechar para realizar varias trading actividades. Para obtener más detalles, consulte el Trading Documentación de la API.

    API de intermediario

    La API Broker le permite realizar varias tareas de corretaje, por ejemplo, creación y manejo de cuentas de usuario, colocación y gestión de pedidos en nombre de los usuarios, etc.

    debes registrarte para la API del corredor para acceder a los puntos finales de la API del intermediario.Página de registro de corredores de Alpaca Markets

    Recibirá un código de verificación que deberá ingresar para activar su cuenta. Inicie sesión en su cuenta de Broker API y seleccione la opción “API/Devs” en la barra lateral izquierda. Haga clic en el botón “Generar” para generar la clave y el secreto de la API de su corredor. Alpaca Markets Broker API Generar página de claves

    Él CorredorCliente La clase le permite llamar a varios puntos finales de intermediarios desde la API de Alpaca.

    Crear cuenta de corredor de Alpaca

    Necesitará una clave API de corredor y un secreto para crear una cuenta de corredor de Alpaca. El método create_account() establece una cuenta de corretaje. El método acepta un objeto de la clase CreateAccountRequest.

    Debe pasar los objetos de las siguientes clases a la clase CreateAccountRequest:

  • Contacto: contiene los datos de contacto del titular de la cuenta
  • Identidad: almacena la información personal del titular de la cuenta
  • Divulgaciones: almacena cualquier información que necesita ser revelada
  • Convenio: el tipo de contrato de cuenta, por ejemplo, contrato de cliente.
  • Este es un ejemplo de cómo crear una cuenta de cliente utilizando información de cliente ficticia.

    from alpaca.broker import BrokerClient
    from alpaca.broker.requests import CreateAccountRequest
    from alpaca.broker.models.accounts import Contact, Identity, Disclosures, Agreement, AccountDocument, TrustedContact
    from alpaca.broker.enums import EmploymentStatus, TaxIdType
    
    import os
    
    api_key = os.environ['BAP-Key']
    api_secret = os.environ['BAP-Secret']
    
    contact = Contact(email_address = "abcd123@gmail.com",
                     phone_number = "0123456789",
                     street_address = ["abc"],
                     city = "London")
    identity = Identity(given_name = "John",
                       family_name = "Doe",
                       date_of_birth = "1990-04-10",
                       country_of_citizenship = "FRA",
                       country_of_tax_residence = "FRA",
                       tax_id = "00000000",
                       tax_id_type = TaxIdType.FRA_SPI
                       )
    disclosure = Disclosures(is_control_person = True,
                            is_affiliated_exchange_or_finra = False,
                            is_politically_exposed = False,
                            immediate_family_exposed = False,
                            #employment_status = EmploymentStatus.STUDENT
                            )
    agreement = Agreement(agreement = "customer_agreement",
                         signed_at = "2022-09-02T15:04:05Z",
                         ip_address = "127.0.0.1"
                         )
    request_params = CreateAccountRequest(contact = contact,
                                          identity = identity,
                                          disclosures = disclosure,
                                          agreements = [agreement]
                                         )
    broker_client = BrokerClient(
                        api_key=api_key,
                        secret_key=api_secret,
                        sandbox=True,
                    )
    broker_client.create_account(account_data = request_params)

    Alpaca API Python Broker Cliente Crear cuenta Json

    Obtener detalles de la cuenta de corredor de Alpaca

    Puede obtener detalles de una cuenta de corretaje utilizando el método get_account_by_id().

    Puede obtener los detalles de la cuenta del corredor utilizando el método get_account_by_id():

    from alpaca.broker import BrokerClient
    import os
    api_key = os.environ['BAP-Key']
    api_secret = os.environ['BAP-Secret']
    broker_client = BrokerClient(
                        api_key=api_key,
                        secret_key=api_secret,
                        sandbox=True,
                    )
    broker_client.get_account_by_id("da4c3378-71c2-433e-bf09-2344eebd3c88"

    Alpaca API Python Broker Cliente Crear cuenta Json

    Lista de todas las cuentas de corredores de Alpaca

    Finalmente, puede recuperar una lista de todas sus cuentas de corredores usando el método list_accounts() de la clase BrokerClient:

    from alpaca.broker import BrokerClient
    import pandas as pd
    import os
    
    api_key = os.environ['BAP-Key']
    api_secret = os.environ['BAP-Secret']
    
    broker_client = BrokerClient(
                        api_key=api_key,
                        secret_key=api_secret,
                        sandbox=True,
                    )
    all_accounts = broker_client.list_accounts()
    
    accounts_dict = [dict(item) for item in all_accounts]
    
    df = pd.DataFrame.from_records(accounts_dict )
    df.head()

    Alpaca API Python Broker Lista de clientes Cuentas DataFrame

    Preguntas frecuentes

    ¿La alpaca está regulada?

    Alpaca es miembro de The Securities Investor Protection Corporation (SIPC) y está regulada por la Autoridad Reguladora de la Industria Financiera FINRA. Si algo sucediera con Alpaca, SIPC ofrece una protección de seguro de hasta $500,000 por cliente.

    ¿De dónde obtiene Alpaca sus datos?

    Alpaca afirma obtener datos en tiempo real con una precisión del 99,5 % de todas las bolsas de valores de EE. UU. Alpaca Securities LLC y Alpaca Crypto LLC prestan servicios de acciones y criptomonedas estadounidenses para Alpaca Markets.

    ¿Se puede corto en alpaca?

    Puedes vender en corto en Alpaca. Sin embargo, es esencial tener en cuenta que es posible que todos los intercambios que figuran en Alpaca no permitan la venta en corto.

    ¿Puedes hacer backtesting en alpaca?

    El backtesting se refiere a estimar la precisión de un trading estrategia probándola en datos históricos. Alpaca trading La API no admite backtesting. Sin embargo, Alpaca proporciona integración con la biblioteca Backtraderque permite realizar pruebas retrospectivas sobre los datos de Alpaca.

    ¿Qué clientes están disponibles para la API de Alpaca?

    La línea de fondo

    Alpaca Markets es un mercado de última generación trading plataforma que proporciona información altamente precisa y en tiempo real sobre el mercado de valores y criptomonedas. A diferencia de las plataformas de corretaje tradicionales, Alpaca Markets es una empresa pionera en API que proporciona API enriquecidas para automatizar trading operaciones. Los desarrolladores, inversores e investigadores pueden aprovechar la API de Alpaca Markets para ofrecer una rápida trading Puntos finales de desarrollo de algoritmos.

    Este artículo explica cómo realizar varias trading operaciones utilizando el cliente Python de la API de Alpaca. La información en este tutorial puede ayudarlo a desarrollar algoritmos trading aplicaciones para usted o sus clientes. Los investigadores también pueden beneficiarse de este artículo en el desarrollo de modelos estadísticos y financieros.

    Deja un comentario