Architect
Architect
Brokerage Institutional Speed

The Modern Brokerage
for Financial Institutions

Access US equities, regulated derivatives, and event contracts through an integrated platform powered by advanced execution technology.

Open Account Open Account
  • Advanced Analytics

    • Live and historical candles
    • Full depth, level 2 order books
    • Real-time positions and P&L
    • Cross-asset margin information
    • Algo execution quality statistics
  • Advanced Order Types

    • Stop-loss, take-profit orders
    • Iceberg orders
    • Click-trading price ladder interface
    • Exchange-supported time-in-force instructions
  • Execution Algorithms

    • TWAP/VWAP/Percent-of-volume
    • Auto-spreader
    • Market-making algos
    • Out-of-the-box algos via UI and API
    • Rest-and-chase for limiting spread-crossing
  • Flexible APIs

    • REST, Websocket, gRPC
    • SDKs in Python, Typescript, and Rust
    • Full order lifecycle
    • Marketdata, positions, P&L, & margin
    • Create custom algos ...
Precision · Speed · Capital Efficiency

Trade Everything in One Place

Trade multiple asset classes with professional tools designed for sophisticated market participants.

Microsoft (MSFT)
NVIDIA (NVDA)
Coinbase (COIN)
Netflix (NFLX)
AMD
Visa (V)
Google (GOOGL)
Tesla (TSLA)

Equities and ETFs

Execute in thousands of stocks and ETFs. Access advanced order types with institutional-grade routing and execution quality.

MID

Options

Real-time options analytics and high-power trading tools enable smart hedging and bold positioning in all market environments.

🔥 Micro Gas
Gold
🌱 Soybean
S&P E-Mini S&P 500
Bitcoin
🏛 US Treasuries
Euro FX
NQ E-mini Nasdaq
CL Crude Oil

Futures

Trade the complete suite of CME-listed derivatives. Leverage execution algorithms and optimize your derivatives strategies.

Why Architect is Different?

Powerful Brokerage
Trading

Open Account Open Account
  • Dashboards

    Dashboards

    Quickly build dashboards that fit your trading style and strategy, choose from a library of widgets and select markets you trade.

  • Algos

    Algos

    Built-in institutional-grade algos to achieve better execution quality. The Time-Weighted Average Price (TWAP) algo attempts to spread out an order evenly throughout a period of time. Using a TWAP execution is one way to achieve an average price that matches the market and can help minimize slippage and reduce costs.

  • Order Types

    Order Types

    Advanced Order Types: Use our Stop Loss and Take Profit order types to have more control over your trading strategies. Send orders quickly and efficiently using our Grid interface.

  • Order Types

    Order Types

    Advanced Order Types: Use our Stop Loss and Take Profit order types to have more control over your trading strategies. Send orders quickly and efficiently using our Grid interface.

  • Algos

    Algos

    Built-in institutional-grade algos to achieve better execution quality. The Time-Weighted Average Price (TWAP) algo attempts to spread out an order evenly throughout a period of time. Using a TWAP execution is one way to achieve an average price that matches the market and can help minimize slippage and reduce costs.

  • Dashboards

    Dashboards

    Quickly build dashboards that fit your trading style and strategy, choose from a library of widgets and select markets you trade.

API

Multi-language API access

Develop execution algorithms, stream market data, access positions and P&L and more using our versatile, multi-language APIs.

Open API Docs Open API Docs
Rust Python JavaScript
from architect_py.client import Client
from architect_py.graphql_client.send_order import SendOrder
import asyncio
from typing import Optional

async def example_simple_algo(
    host: str,
    api_key: str,
    api_secret: str,
    market_id: str
):
    architect = Client(
        host=host,
        api_key=api_key,
        api_secret=api_secret,
    )

    for i in range(10):
        order = await simple_bid_mid_strategy(market_id, 1, architect)

        if order:
            await asyncio.sleep(3)

            orders = await architect.get_open_orders()
            for order in orders.open_orders:
                await architect.cancel_order(order.order.id)

        print(f"Order {i} sent!")


async def simple_bid_mid_strategy(
    market_id: str,
    quantity: int,
    architect: Client
) -> Optional[SendOrder]:

    to_send, price = await get_mid_price(market_id, architect)

    if to_send and price:
        return await architect.send_limit_order(
            market_id,
            "buy",
            price,
            quantity,
        )
Architect Brokerage

The Future of
Trading Starts Here

Open an account and start trading equities, options, futures, and more with institutional-grade tools.