# Aster DEX API Reference: Every Public Endpoint, Verified by Calling It

> An independent reference for Aster's public REST and WebSocket API. Every endpoint below was called on 2026-09-08 and the response shapes are what came back, including where they differ from Binance.

- Source: https://asterpedia.com/ecosystem/aster-api-reference
- Category: ecosystem
- Published: 2026-09-08
- Updated: 2026-09-08
- Publisher: Asterpedia (https://asterpedia.com)

---

Somebody pasted a raw Aster endpoint URL into Google and landed on this site, on a page about how we check our figures rather than on anything describing the API. That gap is what this page closes.

This is an independent reference for Aster's public market-data API. Every endpoint below was called from a plain HTTPS client on **September 8, 2026**, and the field lists are read off what actually came back. Nothing here is paraphrased from documentation. Where an endpoint behaves differently from the Binance API it is modeled on, that difference is written down rather than smoothed over, because that difference is the reason an independent reference is worth reading at all.

> **Key takeaway:** Aster runs a Binance-compatible public API across four hosts and needs no key for market data. The two things most likely to break a client built on Binance assumptions: funding is **not** uniformly eight-hourly (323 of 736 markets settle hourly), and an unknown path returns an **HTML** error page rather than JSON.

## Base URLs and what each host serves

Four hosts, split by product and by transport. All of them answered on the date above.

| Host | Serves | Path prefix |
|---|---|---|
| `https://fapi.asterdex.com` | Perpetual futures REST | `/fapi/v1/` |
| `https://sapi.asterdex.com` | Spot REST | `/api/v1/` |
| `wss://fstream.asterdex.com` | Futures WebSocket streams | `/ws/` and `/stream` |
| `wss://sstream.asterdex.com` | Spot WebSocket streams | `/ws/` and `/stream` |

`GET /fapi/v1/exchangeInfo` reports `"futuresType": "U_MARGINED"`, and the symbols it lists are quoted in `USDT`, `USD1` and `U`. There is one perpetual universe rather than a split across sub-exchanges, which is worth saying because several competing venues do split theirs.

None of the endpoints below required a key, a signature, a timestamp or an account. Two related endpoints do: `GET /fapi/v1/historicalTrades` and `GET /fapi/v1/leverageBracket` both returned `HTTP 401` with `{"code":-2014,"msg":"API-key format invalid."}` when called without one. The second is worth flagging for anyone modelling risk: **maximum leverage per market cannot be read from the public API.**

## Public futures endpoints

All verified 2026-09-08 against `https://fapi.asterdex.com`.

### Connectivity: ping and time

`GET /fapi/v1/ping` takes no parameters and returns an empty object, `{}`. `GET /fapi/v1/time` returns a single field:

```json
{"serverTime":1788860272506}
```

Milliseconds since epoch, UTC. `exchangeInfo` reports `"timezone":"UTC"`, and every timestamp on every endpoint below is milliseconds.

### Exchange metadata: exchangeInfo

`GET /fapi/v1/exchangeInfo` takes no parameters and is the heaviest response on the API at roughly 800 KB. Top-level keys: `timezone`, `serverTime`, `futuresType`, `rateLimits`, `exchangeFilters`, `assets`, `symbols`.

At the moment of the snapshot it carried **588 symbols** and **34 margin assets**. Symbol statuses broke down as 568 `TRADING`, 15 `SETTLING` and 5 `PENDING_TRADING`, so a client that assumes everything listed is tradeable will try to price twenty markets that are not.

Each symbol object carries the Binance fields you would expect, plus several Aster does not share with it. Reading `ASTERUSDT`:

```json
{
  "symbol": "ASTERUSDT",
  "pair": "ASTERUSDT",
  "contractType": "PERPETUAL",
  "status": "TRADING",
  "baseAsset": "ASTER",
  "quoteAsset": "USDT",
  "pricePrecision": 5,
  "onboardDate": 1758178800000,
  "orderTypes": ["LIMIT","MARKET","STOP","STOP_MARKET","TAKE_PROFIT","TAKE_PROFIT_MARKET","TRAILING_STOP_MARKET"],
  "timeInForce": ["GTC","IOC","GTX","HIDDEN"],
  "filters": ["PRICE_FILTER","LOT_SIZE","MARKET_LOT_SIZE","MAX_NUM_ORDERS","MAX_NUM_ALGO_ORDERS","MIN_NOTIONAL","PERCENT_PRICE"]
}
```

Two things in there are Aster-specific and neither appears in a Binance response.

`timeInForce` includes **`HIDDEN`**, on all 588 symbols. That is the venue's [hidden encrypted order mode](https://asterpedia.com/privacy/aster-hidden-orders-explained) surfaced as a public order attribute, which makes it the only part of Aster's privacy positioning that is checkable from outside the app.

`underlyingSubType` classifies what the contract tracks, with values including `STOCK`, `Semiconductor`, `Commodities`, `ETF`, `Meme`, `AI`, `pre-launch` and `USD1-RWA`. That is how you separate crypto perps from the [24/7 tokenized stock and commodity markets](https://asterpedia.com/guides/trading) programmatically, and it is the field our own [listings register](https://asterpedia.com/listings) reads.

Also present on each symbol and absent from Binance: `symbolType`, `tradingMode`, `name`, `channel`, `sequenceNo`, `twapMinNotional`, `imn`, `tags`, `settlePlan`, `triggerProtect`, `liquidationFee` and `marketTakeBound`.

### Order book: depth

`GET /fapi/v1/depth?symbol=BTCUSDT&limit=5`

```json
{
  "lastUpdateId": 532816372677,
  "E": 1788860273018,
  "T": 1788860273000,
  "bids": [["78619.9","1.529"],["78618.7","1.355"]],
  "asks": [["78620.0","0.871"],["78622.5","0.011"]]
}
```

`limit` is not free-form. The values 5, 10, 20, 50, 100, 500 and 1000 all returned data. `limit=3` returned `{"code":-4021,"msg":"3 is not valid depth limit"}` and `limit=5000` returned `-1130`. Prices and quantities are strings, as they are everywhere on this API.

### Trades: trades, aggTrades, historicalTrades

`GET /fapi/v1/trades?symbol=BTCUSDT&limit=2` returns objects with `id`, `price`, `qty`, `quoteQty`, `time`, `isBuyerMaker`.

`GET /fapi/v1/aggTrades?symbol=BTCUSDT&limit=1` returns the compressed form with `a` (aggregate id), `p`, `q`, `f` and `l` (first and last trade id), `T`, `m`:

```json
[{"a":86864991,"p":"78641.5","q":"0.001","f":146767981,"l":146767981,"T":1788860290800,"m":false}]
```

`GET /fapi/v1/historicalTrades` requires a key and returned `401` without one.

### Candles: klines and its three siblings

Four kline endpoints answered, all returning the same twelve-element array shape:

- `GET /fapi/v1/klines?symbol=&interval=&limit=`
- `GET /fapi/v1/indexPriceKlines?pair=&interval=&limit=` (note the parameter is `pair`, not `symbol`)
- `GET /fapi/v1/markPriceKlines?symbol=&interval=&limit=`
- `GET /fapi/v1/premiumIndexKlines?symbol=&interval=&limit=`

```json
[[1788858000000,"78395.6","78632.7","78305.6","78630.7","256.739",
  1788861599999,"20135460.6338",2242,"138.708","10878107.3396","0"]]
```

In order: open time, open, high, low, close, volume, close time, quote volume, trade count, taker buy base volume, taker buy quote volume, and a trailing `"0"` that carries no information. On the three non-`klines` variants every volume field is `"0"`, because an index or mark price has no volume. An invalid `interval` returns `{"code":-1120,"msg":"Invalid interval."}`.

### Mark price and funding: premiumIndex

`GET /fapi/v1/premiumIndex?symbol=BTCUSDT`

```json
{
  "symbol": "BTCUSDT",
  "markPrice": "78625.33116305",
  "indexPrice": "78650.73760870",
  "estimatedSettlePrice": "78465.85329783",
  "lastFundingRate": "0.00008144",
  "interestRate": "0.00010000",
  "nextFundingTime": 1788883200000,
  "time": 1788860274000
}
```

Called without a `symbol` it returns every market in one array. **`lastFundingRate` is the rate for one settlement interval, and that interval is not the same on every market.** See the funding section below before doing anything arithmetic with it.

### Funding history and cadence: fundingRate and fundingInfo

`GET /fapi/v1/fundingRate?symbol=BTCUSDT&limit=2` returns the settled history:

```json
[{"symbol":"BTCUSDT","fundingTime":1788825600000,"fundingRate":"0.00003341"},
 {"symbol":"BTCUSDT","fundingTime":1788854400000,"fundingRate":"0.00006232"}]
```

`GET /fapi/v1/fundingInfo` is the endpoint most likely to be missed, and it is the one that makes the rest of the funding data safe to use. It takes no parameters and returned 736 rows:

```json
{"symbol":"BTCUSDT","interestRate":"0.00010000","time":1788860399000,
 "fundingIntervalHours":8,"fundingFeeCap":0.003,"fundingFeeFloor":-0.003}
```

`fundingIntervalHours` is the settlement cadence for that specific market, and `fundingFeeCap` and `fundingFeeFloor` are its clamp. Both vary: caps observed on the same call ranged from 0.003 to 0.03.

### Ticker: 24hr, price, bookTicker

`GET /fapi/v1/ticker/24hr?symbol=BTCUSDT` returns `priceChange`, `priceChangePercent`, `weightedAvgPrice`, `lastPrice`, `lastQty`, `openPrice`, `highPrice`, `lowPrice`, `volume`, `quoteVolume`, `openTime`, `closeTime`, `firstId`, `lastId`, `count`. `quoteVolume` is the USD-denominated figure, and it is the one to sum for a venue-wide volume number.

`GET /fapi/v1/ticker/price?symbol=BTCUSDT` returns `{"symbol","price","time"}` and `GET /fapi/v1/ticker/bookTicker?symbol=BTCUSDT` returns `{"symbol","bidPrice","bidQty","askPrice","askQty","time","lastUpdateId"}`. Both carry a `time` field that Binance's futures equivalents omit.

### Open interest and index data

`GET /fapi/v1/openInterest?symbol=BTCUSDT` returns `{"symbol","openInterest","time"}`, where `openInterest` is denominated in the base asset. Multiply by mark price for a USD figure.

`GET /fapi/v1/assetIndex` returns the multi-asset collateral index per cross-quoted symbol, with `index`, `bidBuffer`, `askBuffer`, `bidRate`, `askRate` and the `autoExchange` variants of each.

`GET /fapi/v1/indexInfo` answered `200` with an empty array, `[]`. It exists and carries nothing.

`GET /futures/data/openInterestHist` and `GET /fapi/v1/constituents`, both present on Binance, returned a 404 on Aster. There is no historical open-interest series in the public API.

## Public spot endpoints

Spot lives on a different host with a different prefix: `https://sapi.asterdex.com/api/v1/`. `ping`, `time`, `exchangeInfo`, `depth`, `trades`, `aggTrades`, `klines`, `ticker/price`, `ticker/bookTicker` and `ticker/24hr` all answered with no key.

`exchangeInfo` carried **68 spot symbols**, all `TRADING`, quoted in `USDT`, `USD1` and `FORM`. Each symbol object carries a `listingTime` and a `baseAssetAddress`, the on-chain contract address of the base token, which the futures response has no equivalent of.

The one response shape that genuinely differs from Binance is spot `trades`:

```json
[{"id":22920088,"price":"0.77041","qty":"25.96","baseQty":"33.69634351",
  "time":1788860309177,"isBuyerMaker":false}]
```

`baseQty` is not a Binance field. Spot `depth` rejects `limit=3` with the same `-4021` the futures endpoint uses, and accepts 5 through 1000.

## WebSocket streams

Both stream hosts accept the Binance subscription grammar. Every stream below was opened and a real message read from it on the same date.

**Futures**, `wss://fstream.asterdex.com`:

| Stream | First message type |
|---|---|
| `/ws/btcusdt@aggTrade` | `{"e":"aggTrade","E","a","s","p","q","f","l","T","m"}` |
| `/ws/btcusdt@markPrice@1s` | `{"e":"markPriceUpdate","E","s","p","P","i","r","T"}` |
| `/ws/btcusdt@kline_1m` | `{"e":"kline","E","s","k":{...}}` |
| `/ws/btcusdt@bookTicker` | `{"e":"bookTicker","u","s","b","B","a","A","T","E"}` |
| `/ws/btcusdt@depth5@100ms` | `{"e":"depthUpdate","E","T","s","U","u","pu","b","a"}` |
| `/ws/!markPrice@arr@1s` | an array of `markPriceUpdate` objects, all symbols |
| `/stream?streams=a/b` | `{"stream":"...","data":{...}}` |

On `markPriceUpdate`, `p` is mark price, `i` is index price, `P` is the estimated settle price, `r` is the funding rate for that market's own interval and `T` is its next funding time. The combined `/stream` form wraps each message in a `stream` and `data` envelope, exactly as Binance does.

**Spot**, `wss://sstream.asterdex.com`: `/ws/asterusdt@aggTrade` and `/ws/asterusdt@ticker` both delivered. The `24hrTicker` payload uses the same single-letter keys as Binance (`p`, `P`, `w`, `c`, `o`, `h`, `l`, `v`, `q`, `O`, `C`, `F`, `L`, `n`).

## Rate limits and response headers

`exchangeInfo` publishes the limits on each host, and they are not the same:

| Host | Request weight | Orders per minute | Orders per 10s |
|---|---|---|---|
| `fapi.asterdex.com` | 2400 / minute | 1200 | 300 |
| `sapi.asterdex.com` | 6000 / minute | 6000 | 1000 |

Every response carried an `X-MBX-USED-WEIGHT-1M` header giving the weight consumed in the current minute, which is the counter to watch rather than counting requests yourself. Responses also carried `x-response-time` and `Access-Control-Allow-Origin: *`, and CloudFront headers (`X-Cache`, `X-Amz-Cf-Pop`) showing the API is served from a CDN edge.

We did not deliberately breach the limit, so **what Aster returns on an over-limit request is untested here** and is deliberately not stated. Binance answers `429` and then `418`; whether Aster matches that is not something this page can claim.

Error responses observed, all as JSON with an HTTP status to match:

| Code | HTTP | Message |
|---|---|---|
| `-1102` | 400 | Mandatory parameter was not sent, was empty/null, or malformed |
| `-1120` | 400 | Invalid interval |
| `-1121` | 400 | Invalid symbol |
| `-1130` | 400 | Data sent for parameter is not valid |
| `-4021` | 400 | Not a valid depth limit |
| `-2014` | 401 | API-key format invalid |

## Where the behavior differs from a Binance client's assumptions

This is the section the rest of the page exists to support. Five differences, each measured rather than inferred, each dated **2026-09-08**.

### Funding is not eight-hourly

Reading `fundingInfo` for all 736 markets in one call gives four distinct cadences:

| `fundingIntervalHours` | Markets |
|---|---|
| 1 | 323 |
| 2 | 3 |
| 4 | 136 |
| 8 | 274 |

Only 274 of 736 settle on the eight-hour clock a Binance-shaped client assumes. Confirmed against settled history: `BTCUSDT` and `ETHUSDT` show eight-hour gaps in `fundingRate`, `ASTERUSDT` and `XAUUSDT` show four, and `SUSHIUSDT` shows one.

The practical consequence is that annualizing a rate as `rate × 3 × 365` is correct for 37% of the market list and overstates an hourly market **eightfold**. The correct form reads the interval per symbol:

```js
const info = await fetch('https://fapi.asterdex.com/fapi/v1/fundingInfo').then(r => r.json());
const hours = new Map(info.map(f => [f.symbol, f.fundingIntervalHours]));
const annualized = rate * (24 / (hours.get(symbol) ?? 8)) * 365;
```

We had this wrong on our own [market pages](https://asterpedia.com/markets) until this reference was written, which is a reasonable illustration of how easily the assumption survives.

### The symbol lists do not agree with each other

Four "list everything" endpoints, called in parallel at 09:42 UTC so the counts are one instant rather than a drifting sequence:

| Endpoint | Symbols returned |
|---|---|
| `/fapi/v1/exchangeInfo` | 588 |
| `/fapi/v1/premiumIndex` | 736 |
| `/fapi/v1/fundingInfo` | 736 |
| `/fapi/v1/ticker/24hr` | 583 |

**149 symbols are priced by `premiumIndex` but are not listed in `exchangeInfo` at all**, among them `GNSUSD`, `AAPLUSD`, `USD1USD` and the `SHIELD`-prefixed markets. One symbol, `MBLUSDT`, goes the other way. Build the tradeable universe from `exchangeInfo` and join the rest onto it, rather than trusting any single list to be complete.

### An unknown path returns HTML, not JSON

`GET /fapi/v1/nonexistent` returns `404` with a full HTML error page. Any client that calls `.json()` on a non-2xx response will throw a parse error rather than surface the status, which is a confusing failure to debug. Check the status code before parsing.

### Some Binance endpoints are simply absent

`/futures/data/openInterestHist` and `/fapi/v1/constituents` both 404. `/fapi/v1/indexInfo` exists but returns `[]`. There is no public historical open-interest series.

### Leverage caps are not public

`/fapi/v1/leverageBracket` needs a key. Per-market maximum leverage, including the [1001x mode](https://asterpedia.com/guides/trading/aster-1001x-leverage-explained) Aster is known for, is not readable without an account, and `exchangeInfo` does not carry it either.

> **Warning:** This page describes what endpoints return. It says nothing about what to do with the data, and no figure here is a signal, a strategy or a forecast. Aster ships changes quickly, so treat every shape above as a dated observation and re-check before depending on it.

## Methodology

Every endpoint on this page was called from a plain HTTPS client with no API key, no proxy and no library, against the hosts named at the top, between 09:38 and 09:43 UTC on **2026-09-08**. Field lists were read from the responses. Counts (588 symbols, 736 funding rows, the interval split) come from parsing those responses, not from any published figure.

This is an **unofficial** reference. Asterpedia is not affiliated with Aster DEX and has no access to anything a reader does not. Aster's own documentation lives at [docs.asterdex.com](https://docs.asterdex.com), and the app itself is at [asterdex.com](https://www.asterdex.com/en/referral/MMTz04). Where this page and the official documentation disagree, this page records what the endpoint returned on the date above, which may be a documentation lag or may be a change shipped since. It is not a claim that the documentation is wrong.

Nothing here documents authenticated or trading endpoints, and no credential appears on this page. Anyone building order placement against Aster should work from the official documentation, because a wrong assumption about a signed endpoint costs money in a way a wrong assumption about a ticker does not.

For how we verify figures across the rest of this site, see [our methodology](https://asterpedia.com/methodology). For what Aster lists and when each market appeared, the [listings register](https://asterpedia.com/listings) is built from `exchangeInfo` on every build.

## Frequently asked questions

### Does the Aster DEX API need an API key?

Not for market data. Every endpoint documented on this page returned data over plain HTTPS with no key, no signature and no account. Two endpoints we tested do require a key and returned HTTP 401 with code -2014 without one: /fapi/v1/historicalTrades and /fapi/v1/leverageBracket. That second one matters, because it means maximum leverage per market is not readable from the public API.

### What is the base URL for the Aster API?

There are four hosts. Perpetual futures REST is https://fapi.asterdex.com, spot REST is https://sapi.asterdex.com, futures WebSocket streams are at wss://fstream.asterdex.com and spot streams at wss://sstream.asterdex.com. The futures paths sit under /fapi/v1/ and the spot paths under /api/v1/.

### How often does Aster settle funding?

It depends on the market, which is the single most common mistake made about this API. Reading GET /fapi/v1/fundingInfo on September 8, 2026 returned 736 symbols split across four cadences: 323 settle hourly, 3 every two hours, 136 every four hours and 274 every eight hours. Annualizing every rate as though it were eight-hourly overstates an hourly market by a factor of eight.

### Is the Aster API compatible with Binance client libraries?

Largely, but not exactly. Paths, parameters and most response fields match Binance USD-M futures closely enough that a Binance client will work for common calls. The differences we measured are that unknown paths return an HTML error page rather than JSON, the /futures/data/ endpoints are absent, spot trades carry an extra baseQty field, and the symbol lists returned by exchangeInfo, premiumIndex and ticker/24hr do not agree with each other.

### Can the Aster API be called directly from a browser?

Yes, for the public market-data endpoints. Responses we checked carried Access-Control-Allow-Origin set to a wildcard, so a browser can call them from any origin without a proxy. That is an observation about the responses served on September 8, 2026, not a commitment by Aster to keep it that way.