Aster API Guide (2026): V3 API Wallets, EIP-712 Signing, Python Orders, WebSocket Streams and Rate Limits

The Aster API is a Binance-style futures API (/fapi/v3/... paths on fapi.asterdex.com, symbol@stream WebSocket names) with Web3 authentication: in V3 an agent key you authorise from your wallet signs each request as EIP-712 data, where V1 used an HMAC secret. The rest of this guide is the detail: endpoints, signing, a Python order example, streams, limits, errors and a bot blueprint. Choosing the venue first? Read the Aster DEX review.

1. V1 vs V3: which Aster API to use

Aster runs its order book on its own Aster Chain L1. The official docs repository says plainly: use V3 for all new integrations. The business functions (orders, positions, leverage, transfers) are broadly the same in both versions; what changes is authentication and the execution path.

Sources: asterdex/api-docs README (re-read October 19, 2026) and "Aster API V1 vs V3" overview; the API Management page shows the same notice. Some pages on docs.asterdex.com still describe the V1 key-and-secret flow.

2. Endpoints, SDKs and testnet

Related:Aster review 2026

SDKs. Aster does not publish a maintained V3 SDK. The docs ship Python examples that use requests and eth-account, a demo/ folder (agent registration, deposits and withdrawals, Solana agents) and a JavaScript consolidation script. The GitHub organisation also has aster-connector-python, a V1 (key and secret) connector last updated in March 2025, plus aster-mcp and aster-skills-hub for AI-agent tooling. In practice you write a small signing module (below) and call the REST endpoints directly.

On October 19, 2026 GET /fapi/v3/exchangeInfo listed 605 perpetual symbols with status TRADING (578 quoted in USDT, 25 in USD1, 2 in U; 584 in September). Always read symbol rules from this endpoint rather than hard-coding them.

3. Creating an API wallet (agent)

In the app

1. Fund the account first. Since September 1, 2026, authenticated V3 endpoints only work after the main wallet has completed a deposit (see the Aster deposit guide).
2. Go to asterdex.com/en/api-wallet (the Pro API tab in the API menu) and connect your main wallet.
3. Use the button to authorise a new API wallet (it appears once your wallet is connected). The page's table lists Account, API Wallet Name, API Wallet Address, Permission and Valid Until for each agent.
4. Give the agent a name, choose its permissions, set an expiry, and sign with your main wallet. Store the agent's private key in your bot's secret store.

Via the API

POST /fapi/v3/registerAndApproveAgent (weight 50) registers and approves an agent in one call. Its parameters: user, nonce, agentName, agentAddress, expired (milliseconds), signatureChainId (56 for EVM wallets, 101 for Solana), canSpotTrade, canPerpTrade, canWithdraw, optional ipWhitelist and agentCode, and a signature from the main wallet. The docs describe agentCode as a “referral/invitation code for agent registration”. EVM wallets sign EIP-712 typed data and Solana wallets sign Ed25519; here the main wallet signs with domain chain ID = signatureChainId (56 or 101), not the 1666 used for trading requests. For this call the nonce must be within 10 seconds of server time. If canWithdraw is true, an IP whitelist is mandatory. There are matching endpoints to update, list and delete agents.

4. How V3 signing works

1. Collect the business parameters (for an order: symbol, side, type, quantity, price, timeInForce…).
2. Add user (your main wallet address), signer (the API wallet address) and nonce (current time in microseconds).
3. URL-encode them into one string, for example symbol=BTCUSDT&side=BUY&...&nonce=....
4. Put that string in the msg field of an EIP-712 message whose domain is name AsterSignTransaction, version 1, chain ID 1666 and a zero verifying contract.
5. Sign with the API wallet's private key and send the parameters plus signature as a form body (or query string).

The nonce rules matter for bots. A nonce already used is rejected as a duplicate; a nonce more than 60 seconds away from server time is rejected as expired; and each agent address keeps only its 100 most recent nonces, so a nonce older than all of them is also rejected. Nonces are tracked per agent address, so separate bots should use separate agents. The docs list incorrect parameter sorting, mixing milliseconds with microseconds, forgetting user or signer, and assuming V3 is still HMAC as the most common migration mistakes. The safest rule: sign exactly the URL-encoded string you send, in the same order, as the official Python example does.

5. Python example: place and cancel an order

This follows the official V3 example, updated for the current eth-account release (0.14), where encode_structured_data from the docs has been replaced by encode_typed_data. Install with pip install requests eth-account.

import os, time, urllib.parse, requests
from eth_account import Account
from eth_account.messages import encode_typed_data

HOST = "https://fapi.asterdex.com"
USER = os.environ["ASTER_USER"]            # main wallet address
SIGNER = os.environ["ASTER_SIGNER"]        # API wallet address
KEY = os.environ["ASTER_SIGNER_KEY"]       # API wallet private key

def sign(params):
    params = dict(params, user=USER, signer=SIGNER,
                  nonce=str(time.time_ns() // 1000))   # microseconds
    msg = urllib.parse.urlencode(params)
    typed = {
        "types": {
            "EIP712Domain": [
                {"name": "name", "type": "string"},
                {"name": "version", "type": "string"},
                {"name": "chainId", "type": "uint256"},
                {"name": "verifyingContract", "type": "address"}],
            "Message": [{"name": "msg", "type": "string"}]},
        "primaryType": "Message",
        "domain": {"name": "AsterSignTransaction", "version": "1",
                   "chainId": 1666,
                   "verifyingContract": "0x" + "0" * 40},
        "message": {"msg": msg}}
    sig = Account.sign_message(encode_typed_data(full_message=typed), private_key=KEY)
    # eth-account 0.14 returns hex without "0x"; the docs' examples send 0x-prefixed signatures
    params["signature"] = sig.signature.to_0x_hex()
    return params

order = sign({"symbol": "BTCUSDT", "side": "BUY", "type": "LIMIT",
              "timeInForce": "GTX",           # post-only
              "quantity": "0.001", "price": "80000",
              "newClientOrderId": "bot-0001"})
r = requests.post(HOST + "/fapi/v3/order", data=order)
print(r.status_code, r.text)

cancel = sign({"symbol": "BTCUSDT", "origClientOrderId": "bot-0001"})
print(requests.delete(HOST + "/fapi/v3/order", data=cancel).text)

Why these numbers: on October 19, 2026 (06:07 UTC) BTCUSDT traded at $82,768.0. Its filters were tick size 0.1, step size 0.001, minimum quantity 0.001 BTC and minimum notional $5, so 0.001 BTC (about $83) is the smallest order. A post-only buy at $80,000 rests below the market. On a 0% maker fee it costs nothing if it fills; the same size as a market order would pay 0.04% taker, about $0.033. Run the script against the testnet host (and chain ID 714, per the official demo script) first. If the signature is rejected, compare your string byte for byte with the demo scripts in the api-docs repo. The docs’ own sample still imports encode_structured_data and points at a fapi3 host; the base endpoint they document for production is fapi.asterdex.com.

6. Order types and symbol filters

• Order types: LIMIT, MARKET, STOP, STOP_MARKET, TAKE_PROFIT, TAKE_PROFIT_MARKET, TRAILING_STOP_MARKET (callback rate 0.1–5%).
• Time in force: GTC, IOC, GTX (post-only) and HIDDEN (a HIDDEN order is not visible in the order book). FOK is not offered in V3 (re-checked October 19, 2026; Binance-ported code that sends FOK must change).
• Triggers: workingType MARK_PRICE or CONTRACT_PRICE (the default is CONTRACT_PRICE, the last price), with optional priceProtect.
• Newer options: BBO pegging (pegPriceType COUNTERPARTY_1 or QUEUE_1 plus pegOffset), per-order self-trade prevention (stpMode EXPIRE_TAKER, EXPIRE_MAKER or EXPIRE_BOTH), chase orders, strategy orders, batch place, batch modify and batch cancel.
• Hedge mode: send positionSide LONG or SHORT; reduceOnly cannot be used in hedge mode.
• Filters (from exchangeInfo): PRICE_FILTER (tick size), LOT_SIZE and MARKET_LOT_SIZE (step and max size), MAX_NUM_ORDERS (200 on BTCUSDT), MAX_NUM_ALGO_ORDERS (10), MIN_NOTIONAL ($5) and PERCENT_PRICE. On BTCUSDT a buy must be at most 1.02× mark price and a sell at least 0.98×.
• Dead man's switch: POST /fapi/v3/countdownCancelAll (weight 10) cancels all orders on a symbol when a countdown expires. The docs suggest calling it every 30 seconds with 120,000 ms; send 0 to stop the timer.

For the trading side of these orders, see Aster advanced order types, the TP/SL bracket walkthrough and tick size and lot size explained.

7. WebSocket market and user-data streams

Base URL wss://fstream.asterdex.com. Every stream in the V3 docs, with the update speed they state (October 19, 2026):

Source: “Websocket Market Streams” and “User Data Streams” in aster-finance-futures-api-v3.md. Symbols are lowercase (btcusdt@depth5); !…@arr streams cover every market at once.

• URLs: raw streams at wss://fstream.asterdex.com/ws/<stream>, combined streams at /stream?streams=a/b/c. Symbols are lowercase.
• Live control: send SUBSCRIBE, UNSUBSCRIBE, LIST_SUBSCRIPTIONS, SET_PROPERTY or GET_PROPERTY messages with an integer id.
• Connection rules: a connection lasts at most 24 hours. The server pings every 5 minutes and drops you if it sees no pong within 15 minutes. Clients may send 10 messages per second, and one connection can carry 200 streams. Repeated disconnections can get an IP banned.
• User data: POST /fapi/v3/listenKey returns a key valid for 60 minutes; PUT extends it and DELETE closes it. Connect to /ws/<listenKey> for margin calls, balance and position updates, order updates, leverage changes and announcements. Events may arrive out of order under load, so sort by the E event time.

The docs recommend using the user-data stream, not REST polling, for order status and positions during volatile markets. To keep a local order book, use the standard recipe: open the diff-depth stream, fetch a /fapi/v3/depth snapshot, then apply the buffered updates.

8. Rate limits and bans

Live /fapi/v1/exchangeInfo and /fapi/v3/exchangeInfo rateLimits, October 19, 2026 (identical, unchanged since September). Weights: new order 0, Noop 1, listenKey 1, countdownCancelAll 10, registerAndApproveAgent 50; depth scales with the limit parameter.

A 429 means back off. Continuing after 429s gets the IP auto-banned with HTTP 418, and bans escalate from 2 minutes to 3 days for repeat offenders. Weight limits are per IP, not per key, so several bots on one server share 2,400. A 503 means the request reached the server but no reply came in time: the order status is unknown, so query it before you resend.

Fees for API traders are the same as in the app: 0% maker / 0.04% taker on standard crypto perps, 0.1% taker on Group B pairs and 0.0125% taker on RWA perps. A bot that takes $1,000,000 of notional pays $400 in taker fees; a maker-only strategy pays nothing. Details and VIP tiers: Aster fee structure.

9. Differences from the Binance API

If you have a Binance USDⓈ-M futures bot, much of it carries over: the /fapi path layout, the JSON shapes, enums (order types, GTX, workingType), filters, the X-MBX-* weight headers, the negative error-code format and the symbol@stream WebSocket naming. Here is what does not carry over:

• Authentication: V3 has no API secret and no HMAC. You need user, signer, a microsecond nonce and an EIP-712 signature. Only the legacy V1 is HMAC, and you can no longer create V1 keys.
• Nonce, not timestamp: 60-second window, 100 remembered nonces per agent.
• Deposit gate: authenticated V3 calls return -5050 until the main wallet has deposited.
• On-chain extras: Noop to cancel still-queued transactions, and guarded cancel endpoints for orders placed on-chain.
• Hosts: fapi/fstream.asterdex.com, and spot on sapi/sstream.asterdex.com.
• Accounts: there is no exchange login or KYC account behind the API; the account is your main wallet address, and deposits and withdrawals go through Aster Chain's validator-confirmed cross-chain system (see the deposit guide).

For a product comparison rather than an API one, see Aster vs Binance perpetuals.

10. Common errors

11. Security checklist

• Trade-only agents. Leave canWithdraw off unless you truly need it, and if you turn it on, the IP whitelist it requires is your second line of defence.
• Short expiries. Set expired / Valid Until to weeks, not years, and rotate agents.
• One agent per bot: nonces are tracked per agent, and a leaked key can be revoked without stopping everything.
• The main wallet key never touches the server; it only signs agent approvals.
• Handle 503 as "unknown" and reconcile with the user-data stream before resending.
• Use countdownCancelAll so a crashed bot does not leave orders behind.
• Migrate old V1 keys to V3 agents; existing V1 keys still work, but V3 is where new features land.

Strategy ideas: automated trading on Aster (next section), multi-DEX arbitrage, and how Aster’s API stacks up against other venues in perp DEX APIs compared. Choosing a venue first? Start with the best DEX guide or what is a DEX.

12. Automated trading on Aster: built-in bots first, then your own

Before you write a bot, check whether Aster already runs the strategy for you. Several automation tools are built into the Pro interface and run on the exchange side, so they keep working when your laptop is closed. We read each of the docs pages below on September 25, 2026.

Grid fills rest on the book, so on standard crypto perps they pay the 0% maker fee; the cost of a grid is the taker fee on any market exit, funding on the inventory it carries, and the risk of the price leaving the range. Every grid order must meet the symbol's minimum notional ($5 on all 605 trading perps in exchangeInfo on October 19, 2026), which is why dense grids need more initial margin. More on these order types in our Aster advanced order types guide.

When to write your own bot

Write code when you need something the built-in tools cannot do: quoting both sides around a fair price you compute yourself, hedging across venues, reacting to funding, or mixing signals. A minimal market-making loop looks like this:

1. Stream the book. Subscribe to <symbol>@depth and keep a local copy (section 7), plus the user-data stream for your fills.
2. Compute a fair price, for example the mid of the best bid and ask, adjusted for your inventory.
3. Quote both sides with post-only (GTX) limit orders a chosen distance from fair price, rounded to the tick and step from exchangeInfo (BTCUSDT: $0.10 tick, 0.001 BTC step, $5 minimum).
4. On each fill, re-quote and check inventory; hedge or flatten with a taker order only when inventory exceeds your limit.
5. Refresh countdownCancelAll every loop so a crash leaves nothing on the book.

What a bot actually pays on Aster

Funding intervals from the live GET /fapi/v1/fundingInfo response on October 19, 2026 (the list includes symbols that are not currently trading). Fees from Aster's fee docs on the same date.

Test before you trust it

• Backtest on real data. GET /fapi/v3/klines returns public candles (we queried BTCUSDT 1h on October 19, 2026). For order-book strategies, record @depth and @aggTrade yourself for a few weeks; a candle backtest cannot tell you whether a passive quote would have filled.
• Run it on the testnet. Point the bot at fapi.asterdex-testnet.com. The faucet gives 1,000 test USDT and 1,000 test ASTER once per day; deposits, withdrawals and internal transfers are disabled there.
• Then go live small, with hard limits the bot cannot override: maximum position, maximum order size, a daily loss limit that cancels everything and stops the process, and an alert when the WebSocket drops.

If you run the same strategy on several venues, compare the costs first: on Hyperliquid the base tier pays 0.015% maker and 0.045% taker (Hyperliquid API bot guide), while a Lighter Standard account pays 0% on both sides but with slower order processing than Premium. See the Aster fee structure for VIP tiers.

FAQ

Running a cross-venue bot? Pair Aster with Hyperliquid, the deepest perp DEX order book. Code HOLYGRAIL gives 4% off fees on your first $25M of volume, and the Hyperliquid API and WebSocket guide covers its streaming API. Before you deposit, the Aster review covers safety and custody, and the Aster referral code page shows how the fee rebate is credited. Lighter's API is covered in the Lighter API guide.

Disclosure: DTLpLc is our Aster referral code; we earn a share of referred users’ trading fees. Endpoints, signing, limits and error codes were checked in Aster’s official API docs, docs site, app pages and live API on October 19, 2026. Aster changes its API often; check the CHANGELOG in github.com/asterdex/api-docs before you deploy. Nothing here is financial advice.