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.
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.
Alpaca 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.
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. 
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:
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.
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 notebookVeamos 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
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.AssetPara 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)
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()
¿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
La API de Market Data tiene cuatro clases principales:
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_dfObtenga 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)
Market 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)
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()
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
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()
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()
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
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)
Crear una orden para vender un activo
El proceso es el mismo para vender un activo excepto por lo siguiente:
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)
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
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
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()
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)
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()
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()
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()
É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.
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. 
É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:
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)
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"
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()
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.