Tick-Based Chart Data

Retrieves tick-based chart bars for a specific symbol. Unlike time-based candles (which close every fixed number of minutes, hours, or days), a tick bar closes every time a fixed number of trades has occurred, making tick charts useful for visualizing market activity rather than the passage of time.

Use Case: Build “N trades per candle” charts (for example, a bar every 100 trades) so momentum and unusual volume are visible even during quiet periods, and load deeper history as a user scrolls a chart backward.

GET /v1/chart/tick-history

Get Tick-Based Chart Data

cURL

curl --request GET \
  --url https://api.aries.com/v1/chart/tick-history \
  --header 'Authorization: Bearer <token>'

200

success

{ "c": [ 130.15, 130.89, 131.24 ], "h": [ 130.28, 131.05, 131.37 ], "l": [ 129.88, 130.09, 130.81 ], "nextTo": "1784677563966606471", "o": [ 129.93, 130.15, 130.89 ], "s": "ok", "t": [ 1784677561000, 1784677562500, 1784677563966 ], "v": [ 1234567, 1345678, 1456789 ] }

What is a tick chart?

A regular chart candle covers a fixed amount of time — a 1-minute candle always covers one minute, whether ten trades happened during it or ten thousand. A tick candle instead covers a fixed number of trades. A 100T candle closes the moment the 100th trade happens, whether that took two seconds during a busy open or two minutes during a quiet afternoon.

This makes tick charts a way to watch activity instead of the clock. When a stock suddenly gets busy, tick candles compress and appear in quick succession; when it goes quiet, they stretch out. Traders use this to spot momentum shifts and unusual volume that a time-based chart can smooth over.

Because a tick candle is built directly from individual trades, resolutions like 1T, 100T, or 1000T cannot be produced by resampling regular time-based candles — they need their own data path, which is why this is a separate endpoint from Historical Bars.

Tick resolutions (1T–1000T) are not supported on /v1/chart/history. Use this endpoint for tick-based candles, and /v1/chart/history for minute/hour/day/week/month candles.

Loading more history (pagination)

A tick chart doesn’t have a fixed calendar, so “give me the next month of data” doesn’t make sense the way it does for a daily chart. Instead, older bars are loaded one page at a time using a pagination token:

1. First request: call the endpoint with symbol, resolution, and countback, and leave cursor out. You get the most recent bars, plus a nextTo value in the response.
2. Scrolling further back: when the user scrolls the chart into the past and more history is needed, call the endpoint again with the same symbol/resolution and set cursor to the nextTo value from the previous response. You get the page of bars immediately before the ones you already have — no gaps and no repeated bars.
3. Reaching the beginning: once there’s no more history to load, the response has no nextTo field. Stop requesting further pages at that point.

Treat cursor/nextTo as an opaque token: always store and forward it exactly as received, and never try to construct, parse, or calculate one yourself.

You may sometimes get fewer bars than you asked for in countback — this is expected, not an error. Each call fetches a bounded amount of trade data to keep response times fast, and a large bar size like 1000T needs far more trades per bar than 1T, so fewer complete bars fit in that budget. Check how many bars actually came back (the length of the t array) and, if you need more, use cursor to load the next page.

Response fields at a glance

Field	Meaning
s	Status: ok (bars available), no_data (nothing found for this symbol/resolution), or error (see errmsg)
t	Bar timestamps, in Unix milliseconds — note this is milliseconds, not seconds like /v1/chart/history
o, h, l, c	Open, high, low, and close price for each bar
v	Total traded volume for each bar
nextTo	Pass this back as cursor to load the next older page; absent when there’s no more history

Every array lines up by index — t[0], o[0], h[0], l[0], c[0], and v[0] all describe the same bar.

Authorizations

Authorization · string · header · required

OAuth2 Bearer token: obtain an access token from the token endpoint and send it in the Authorization header.

Query Parameters

symbol · string · required

Symbol to fetch tick bars for. Use the exact symbol returned by symbol search, such as AAPL for equities.

resolution · enum<string> · required

Tick bar size: the number of trades that make up one bar. Tick bar size: the number of trades that make up one bar. For example, 100T closes a new bar every 100 trades, regardless of how much time that takes. Larger values (e.g. 1000T) smooth out noise and are better suited to a wider chart view; smaller values (e.g. 1T, one trade per bar) show every individual trade and suit a zoomed-in view.

Available options: 1T, 5T, 10T, 25T, 50T, 100T, 250T, 500T, 1000T

Example:

"100T"

countback · integer · default: 300

How many bars to return, counting back from the most recent bar (or from cursor, if provided). Defaults to 300 when omitted. The maximum depends on resolution: each call is bounded by a fixed per-request trade budget, so low-count ticks (e.g. 1T) can return up to 5000 bars, while high-count ticks (e.g. 1000T) may cap out around 50. Requests above the resolution's maximum are silently reduced to it — this is normal, not an error. Use the cursor field to keep loading further back until you have as much history as you need.

Required range: x >= 1

cursor · string

Pagination token for loading OLDER bars, used when a user scrolls a chart backward in time. Omit this parameter for the initial chart load, which returns the most recent bars. To load the page before that, pass the nextTo value from the previous response as cursor. Treat this value as opaque — always pass it back exactly as received; do not attempt to construct, decode, or modify it.

Response

200

application/json

Tick bars in TradingView UDF format, extended with a pagination cursor. Always returns 200; check s (status): ok = data in t, o, h, l, c, v (and usually nextTo); no_data = no matching trade activity, and nextTo will be absent — stop requesting further history; error = errmsg contains reason (e.g. invalid resolution or malformed cursor).

Tick-based chart data returned as parallel arrays, plus a pagination cursor for loading older history. Values at the same index belong to the same bar, so t[0], o[0], h[0], l[0], c[0], and v[0] describe one candle.

s · enum<string> · required

Response status. ok means chart arrays are usable; no_data means no matching trade activity was found; error means read errmsg.

Available options: ok, no_data, error

c · number[]

Close price for each bar. Use the value at the same index as t for chart candles and performance calculations.

errmsg · string

Human-readable error message. Present only when s is error.

h · number[]

Highest traded price during each bar. Use it for candle wicks and intraperiod range.

l · number[]

Lowest traded price during each bar. Use it for candle wicks and intraperiod range.

nextTo · string

Opaque pagination token for loading the next OLDER page of bars. Save this value and send it back as the cursor query parameter when the user scrolls the chart further into the past. Not present when there is no older history left to load — stop requesting further pages when this field is absent.

o · number[]

Open price for each bar. Use the value at the same index as t for candle bodies.

t · integer<int64>[]

Bar timestamps in Unix MILLISECONDS (not seconds, unlike /v1/chart/history). Each timestamp is strictly greater than the one before it, even when many trades happen within the same second. Each timestamp index lines up with open, high, low, close, and volume arrays.

v · integer<int64>[]

Total traded volume for each bar. Use the value at the same index as t for volume charts.