API giao dịch Alpaca Trading 2026: API môi giới chứng khoán không phí để giao dịch theo thuật toán — Hướng dẫn cài đặt

API_KEY = 'PKABCDEF1234567890EXAMPLE'
API_SECRET = 'abcdefghijklmnopqrstuvwxyz1234567890example'
BASE_URL = 'https://paper-api.alpaca.markets'  # Endpoint Paper Trading

// Cấu hình credentials cho JavaScript/Node.js
const API_KEY = 'PKABCDEF1234567890EXAMPLE';
const API_SECRET = 'abcdefghijklmnopqrstuvwxyz1234567890example';
const BASE_URL = 'https://paper-api.alpaca.markets';

# Quản lý credentials an toàn với biến môi trường
import os
from alpaca_trade_api import REST

api = REST(
    key_id=os.getenv('ALPACA_API_KEY'),
    secret_key=os.getenv('ALPACA_SECRET_KEY'),
    base_url='https://paper-api.alpaca.markets'
)

# .env file (thêm vào .gitignore!)
ALPACA_API_KEY=PKABCDEF1234567890EXAMPLE
ALPACA_SECRET_KEY=abcdefghijklmnopqrstuvwxyz1234567890example

# SDK Python
pip install alpaca-trade-api

# SDK JavaScript/Node.js
npm install @alpacahq/alpaca-trade-api

# SDK Go
go get github.com/alpacahq/alpaca-trade-api-go/v3/alpaca

from alpaca_trade_api import REST
import os

api = REST(
    key_id=os.getenv('ALPACA_API_KEY'),
    secret_key=os.getenv('ALPCA_SECRET_KEY'),
    base_url='https://paper-api.alpaca.markets'
)

# Lệnh thị trường — thực hiện ngay lập tức tại giá tốt nhất có sẵn
market_order = api.submit_order(
    symbol='AAPL',
    qty=10,
    side='buy',
    type='market',
    time_in_force='day'
)
print(f"Đơn hàng thị trường đã đặt: {market_order.id}")

# Lệnh hạn mức — chỉ thực hiện khi giá đạt hoặc thấp hơn so với giá hạn mức
limit_order = api.submit_order(
    symbol='TSLA',
    qty=5,
    side='buy',
    type='limit',
    limit_price=180.00,
    time_in_force='gtc'  # Good-til-cancelled
)
print(f"Đơn hàng hạn mức đã đặt: {limit_order.id}")

# Lệnh dừng mất mát — kích hoạt bán thị trường khi giá giảm xuống mức dừng
stop_order = api.submit_order(
    symbol='MSFT',
    qty=20,
    side='sell',
    type='stop',
    stop_price=380.00,
    time_in_force='day'
)

# Lệnh dừng-hạn mức — kết hợp lệnh dừng kích hoạt với thực hiện hạn mức
stop_limit_order = api.submit_order(
    symbol='GOOGL',
    qty=2,
    side='sell',
    type='stop_limit',
    stop_price=165.00,
    limit_price=164.50,
    time_in_force='day'
)

# Lệnh theo dõi dừng — giá dừng theo dõi thị trường tại một khoảng cách cố định
trailing_stop = api.submit_order(
    symbol='AMZN',
    qty=3,
    side='sell',
    type='trailing_stop',
    trail_percent=5.0,  # 5% khoảng cách theo dõi
    time_in_force='gtc'
)

# Mua 500 USD Apple — không phụ thuộc vào giá cổ phiếu
fractional_order = api.submit_order(
    symbol='AAPL',
    notional=500.00,  # Số tiền USD thay vì số lượng cổ phiếu
    side='buy',
    type='market',
    time_in_force='day'
)

# Xây dựng một danh mục đầu tư cân bằng với phân bổ chính xác theo giá trị USD
portfolio = {
    'VTI': 2000.00,   # Tổng thị trường chứng khoán Hoa Kỳ
    'VXUS': 1000.00,  # Chứng khoán quốc tế
    'BND': 1000.00,   # OANDA trái phiếu Hoa Kỳ
    'VNQ': 500.00     # Nhà đất
}

for symbol, amount in portfolio.items():
    order = api.submit_order(
        symbol=symbol,
        notional=amount,
        side='buy',
        type='market',
        time_in_force='day'
    )
    print(f"Đã đặt ${amount} của {symbol}")

# Đặt đơn hàng để thực hiện trong giờ nghiên cứu
extended_hours_order = api.submit_order(
    symbol='SPY',
    qty=50,
    side='buy',
    type='limit',
    limit_price=520.00,
    time_in_force='day',
    extended_hours=True  # Kích hoạt trước thị trường (4:00 AM) và sau giờ làm việc (8:00 PM)
)

# Kiểm tra các giờ giao dịch có sẵn cho một mã chứng khoán
from alpaca_trade_api import REST

api = REST(key_id='YOUR_KEY', secret_key='YOUR_SECRET')
clock = api.get_clock()

print(f"Thị trường {'mở' if clock.is_open else 'đóng'}")
print(f"Giờ mở tiếp theo: {clock.next_open}")
print(f"Giờ đóng tiếp theo: {clock.next_close}")

import asyncio
from alpaca_trade_api.stream import Stream

# Lấy dữ liệu qua giao thức WebSocket
async def xu_ly_giao_dich(t):
    print(f"Giao dịch: {t.symbol} @ ${t.price} x {t.size}")

async def xu_ly_bao_gia(q):
    print(f"Báo giá: {q.symbol} Mua cao: ${q.bid_price} Bán thấp: ${q.ask_price}")

async def xu_ly_than_khoan(bar):
    print(f"Thanh khoản: {bar.symbol} M:{bar.open} C:{bar.high} D:{bar.low} L:{bar.close}")

# Khởi tạo lưu trữ
stream = Stream(
    key_id='YOUR_API_KEY',
    secret_key='YOUR_SECRET_KEY',
    base_url='https://paper-api.alpaca.markets',
    data_feed='iex'  # 'iex' (miễn phí) hoặc 'sip' (tiền tệ)
)

# Đăng ký kênh
stream.subscribe_trades(xu_ly_giao_dich, 'AAPL', 'TSLA', 'MSFT')
stream.subscribe_quotes(xu_ly_bao_gia, 'AAPL', 'TSLA')
stream.subscribe_bars(xu_ly_than_khoan, 'SPY', 'QQQ')

# Chạy lưu trữ
print("Bắt đầu giao thức WebSocket...")
stream.run()

# Kiểu quản lý ngữ cảnh async cho lưu trữ qua giao thức WebSocket
import asyncio
from alpaca_trade_api.stream import Stream

async def chay_strategi_gia_tri():
    stream = Stream(
        key_id='YOUR_API_KEY',
        secret_key='YOUR_SECRET_KEY',
        data_feed='iex'
    )
    
    async def on_than_khoan(bar):
        # Logic chiến lược của bạn ở đây
        if bar.close > bar.vwap * 1.02:
            print(f"Potencial breakout: {bar.symbol} at ${bar.close}")
    
    stream.subscribe_bars(on_than_khoan, 'AAPL', 'MSFT', 'GOOGL', 'AMZN')
    
    # Chạy với việc dọn dẹp phù hợp
    await stream._run_forever()

# asyncio.run(chay_strategi_gia_tri())

// Lưu trữ qua giao thức WebSocket trong Node.js
const Alpaca = require('@alpacahq/alpaca-trade-api');

const alpaca = new Alpaca({
    keyId: 'YOUR_API_KEY',
    secretKey: 'YOUR_SECRET_KEY',
    paper: true
});

const client = alpaca.data_ws;

client.onConnect(() => {
    console.log('WebSocket connected');
    client.subscribe(['alpacadatafeed/T.AAPL', 'alpacadatafeed/T.TSLA']);
});

client.onStockTrade((subject, data) => {
    console.log(`Giao dịch: ${data.sym} @ $${data.p} x ${data.s}`);
});

client.connect();

from alpaca_trade_api import REST
import pandas as pd

api = REST(key_id='YOUR_KEY', secret_key='YOUR_SECRET')

# Lấy thông tin tài khoản
account = api.get_account()
print(f"ID tài khoản: {account.id}")
print(fGiá trị danh mục: ${account.portfolio_value}")
print(fTiền mặt: ${account.cash}")
print(fMô men mua: ${account.buying_power}")
print(fQuyền sở hữu: ${account.equity}")
print(fSố lượng giao dịch trong ngày: {account.daytrade_count}")

# Danh sách tất cả vị trí hiện tại
positions = api.list_positions()
print(f"Số lượng vị trí: {len(positions)}")

for pos in positions:
    print(f"{pos.symbol}: {pos.qty} cổ phiếu @ ${pos.avg_entry_price}")
    print(f"  Hiện tại: ${pos.current_price} | Lợi nhuận chưa thực hiện: ${pos.unrealized_pl} ({pos.unrealized_plpc}%)")

# Lấy vị trí cho một ký hiệu cụ thể
aapl_position = api.get_position('AAPL')
print(f"Vị trí AAPL: {aapl_position.qty} cổ phiếu")
print(fGiá trị thị trường: ${aapl_position.market_value}")
print(fLợi nhuận chưa thực hiện: ${aapl_position.unrealized_pl}")

# Danh sách tất cả các lệnh mở
open_orders = api.list_orders(status='open')
for order in open_orders:
    print(f"Lệnh {order.id}: {order.side} {order.qty} {order.symbol} @ {order.type}")

# Hủy một lệnh cụ thể
api.cancel_order('ORDER_ID_HERE')
print("Lệnh đã bị hủy")

# Hủy tất cả các lệnh mở
api.cancel_all_orders()
print("Tất cả các lệnh đã bị hủy")

# Lấy lịch sử lệnh (các lệnh đóng)
closed_orders = api.list_orders(
    status='closed',
    limit=100,
    after='2026-05-01T00:00:00Z'
)

for order in closed_orders:
    print(f"{order.symbol}: {order.side} {order.filled_qty}/{order.qty} @ ${order.filled_avg_price}")

from alpaca_trade_api import REST
from datetime import datetime, timedelta

api = REST(key_id='YOUR_KEY', secret_key='YOUR_SECRET')

# Lấy các dòng lịch sử trong 6 tháng qua
end_date = datetime.now()
start_date = end_date - timedelta(days=180)

bars = api.get_bars(
    'AAPL',
    timeframe='1Day',
    start=start_date.isoformat(),
    end=end_date.isoformat(),
    feed='iex'
).df

print(f"Trích xuất {len(bars)} dòng")
print(bars.head())

# Lấy các dòng phút cho chiến lược trong ngày
minute_bars = api.get_bars(
    'SPY',
    timeframe='1Min',
    start='2026-05-15T09:30:00Z',
    end='2026-05-15T16:00:00Z',
    feed='iex'
).df

# Tính trung bình động đơn giản
minute_bars['SMA_20'] = minute_bars['close'].rolling(20).mean()
minute_bars['SMA_50'] = minute_bars['close'].rolling(50).mean()

# Tạo tín hiệu
minute_bars['signal'] = 0
minute_bars.loc[minute_bars['SMA_20'] > minute_bars['SMA_50'], 'signal'] = 1
minute_bars.loc[minute_bars['SMA_20'] < minute_bars['SMA_50'], 'signal'] = -1

print(minute_bars[['close', 'SMA_20', 'SMA_50', 'signal']].tail(10))

# Truy xuất nhiều mã chứng khoán hiệu quả
import pandas as pd

symbols = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'META']
all_bars = {}

for symbol in symbols:
    bars = api.get_bars(
        symbol,
        timeframe='1Day',
        start='2026-01-01T00:00:00Z',
        end='2026-05-19T00:00:00Z',
        feed='iex'
    ).df
    all_bars[symbol] = bars['close']

# Tạo DataFrame với tất cả giá đóng cửa
prices_df = pd.DataFrame(all_bars)
print(prices_df.head())

# Tính toán lợi nhuận hàng ngày
returns = prices_df.pct_change().dropna()
print("\nLợi nhuận Hàng Ngày:")
print(returns.head())

"""
Bot Giao Dịch Động Lượng Alpaca
Strategi: Mua khi giá vượt qua SMA 20 kỳ với xác nhận khối lượng
"""
import os
import time
import pandas as pd
from alpaca_trade_api import REST, Stream

# Cấu hình
API_KEY = os.getenv('ALPACA_API_KEY')
API_SECRET = os.getenv('ALPACA_SECRET_KEY')
BASE_URL = 'https://paper-api.alpaca.markets'

WATCHLIST = ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'NVDA']
POSITION_SIZE = 1000  # Số tiền mỗi giao dịch
SMA_PERIOD = 20

class MomentumTrader:
    def __init__(self):
        self.api = REST(key_id=API_KEY, secret_key=API_SECRET, base_url=BASE_URL)
        self.price_history = {s: [] for s in WATCHLIST}
        self.positions_held = set()
    
    def get_sma(self, prices, period):
        """Tính trung bình động đơn giản"""
        if len(prices) < period:
            return None
        return sum(prices[-period:]) / period
    
    def check_for_signal(self, symbol, current_price):
        """Tạo tín hiệu mua/bán dựa trên việc cắt nhau của SMA"""
        self.price_history[symbol].append(current_price)
        
        if len(self.price_history[symbol]) < SMA_PERIOD + 5:
            return None
        
        sma = self.get_sma(self.price_history[symbol], SMA_PERIOD)
        prev_price = self.price_history[symbol][-2]
        prev_sma = self.get_sma(self.price_history[symbol][:-1], SMA_PERIOD)
        
        # Tín hiệu mua: giá vượt qua SMA
        if prev_price <= prev_sma and current_price > sma:
            if symbol not in self.positions_held:
                return 'mua'
        
        # Tín hiệu bán: giá dưới SMA
        if prev_price >= prev_sma and current_price < sma:
            if symbol in self.positions_held:
                return 'bán'
        
        return None
    
    def execute_trade(self, symbol, signal):
        """Thực hiện một giao dịch dựa trên tín hiệu"""
        try:
            if signal == 'mua':
                order = self.api.submit_order(
                    symbol=symbol,
                    notional=POSITION_SIZE,
                    side='buy',
                    type='market',
                    time_in_force='day'
                )
                self.positions_held.add(symbol)
                print(f"MUA {symbol}: ${POSITION_SIZE} | ID Đơn Hàng: {order.id}")
            
            elif signal == 'bán':
                position = self.api.get_position(symbol)
                order = self.api.submit_order(
                    symbol=symbol,
                    qty=position.qty,
                    side='sell',
                    type='market',
                    time_in_force='day'
                )
                self.positions_held.discard(symbol)
                print(f"BÁN {symbol}: {position.qty} cổ phiếu | ID Đơn Hàng: {order.id}")
        
        except Exception as e:
            print(f"Lỗi trong giao dịch cho {symbol}: {e}")
    
    def run(self):
        """Hàm lặp chính sử dụng polling"""
        print("Bot Giao Dịch Động Lượng bắt đầu...")
        
        while True:
            try:
                clock = self.api.get_clock()
                if not clock.is_open:
                    print(f"Thị trường đóng cửa. Mở tiếp theo: {clock.next_open}")
                    time.sleep(60)
                    continue
                
                for symbol in WATCHLIST:
                    # Lấy giá mới nhất
                    bars = self.api.get_latest_bar(symbol)
                    signal = self.check_for_signal(symbol, bars.c)
                    
                    if signal:
                        self.execute_trade(symbol, signal)
                
                time.sleep(60)  # Kiểm tra mỗi phút
                
            except Exception as e:
                print(f"Lỗi trong vòng lặp chính: {e}")
                time.sleep(60)

if __name__ == '__main__':
    trader = MomentumTrader()
    trader.run()

# One-Cancels-Other (OCO) bracket order
bracket_order = api.submit_order(
    symbol='TSLA',
    qty=10,
    side='buy',
    type='limit',
    limit_price=200.00,
    time_in_force='gtc',
    order_class='bracket',
    take_profit=dict(limit_price=220.00),
    stop_loss=dict(stop_price=185.00, limit_price=184.50)
)

# Immediate-Or-Cancel (IOC) order
ioc_order = api.submit_order(
    symbol='SPY',
    qty=100,
    side='buy',
    type='limit',
    limit_price=520.00,
    time_in_force='ioc'  # Cancelled if not filled immediately
)

# Flask webhook handler for external signals
from flask import Flask, request, jsonify
from alpaca_trade_api import REST

app = Flask(__name__)
api = REST(key_id='YOUR_KEY', secret_key='YOUR_SECRET')

@app.route('/webhook/trading-signal', methods=['POST'])
def handle_trading_signal():
    data = request.json
    symbol = data.get('symbol')
    signal = data.get('signal')  # 'buy' or 'sell'
    
    if signal == 'buy':
        order = api.submit_order(
            symbol=symbol,
            notional=1000,
            side='buy',
            type='market',
            time_in_force='day'
        )
        return jsonify({'status': 'success', 'order_id': order.id})
    
    elif signal == 'sell':
        position = api.get_position(symbol)
        order = api.submit_order(
            symbol=symbol,
            qty=position.qty,
            side='sell',
            type='market',
            time_in_force='day'
        )
        return jsonify({'status': 'success', 'order_id': order.id})
    
    return jsonify({'status': 'unknown_signal'}), 400

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)