Bitculator Data API

List coins

Ranked coins with prices, filters and selectors, paginated with Laravel's links + meta envelope. Prices, marketcap and circulating_supply are decimal strings; changes and ranks are numbers.

GET

http://localhost/api/v1/coins

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

type

string optional

coin

Restrict to a single asset type: coin or token.

One of: coin token

status

string optional

active

Listing status: active, delisted, untracked, progressing, awaiting or preparing. Defaults to all public statuses.

One of: active delisted untracked progressing awaiting preparing

search

string optional

bitcoin

Free-text match on name or symbol. Must not be greater than 100 characters.

min_price

number optional

0.5

Only coins priced at or above this USD value. Must be at least 0.

max_price

number optional

100000

Only coins priced at or below this USD value. Must be at least 0.

min_marketcap

number optional

1000000

Only coins with a USD marketcap at or above this value. Must be at least 0.

max_marketcap

number optional

5000000000000

Only coins with a USD marketcap at or below this value. Must be at least 0.

min_volume

number optional

1000000

Only coins with 24h USD volume at or above this value. Must be at least 0.

max_volume

number optional

100000000000

Only coins with 24h USD volume at or below this value. Must be at least 0.

ids

string optional

38,39

Filter to specific coin ids (CSV, up to 100 selectors combined with slugs/symbols). Must not be greater than 1000 characters.

slugs

string optional

bitcoin,ethereum

Filter to specific coin slugs (CSV, up to 100 selectors combined). Must not be greater than 2000 characters.

symbols

string optional

BTC,ETH

Filter to specific coin symbols (CSV, case-insensitive, up to 100 selectors combined). Must not be greater than 1000 characters.

sort

string optional

-marketcap

Comma-separated sort fields; prefix with - for descending. Sortable: marketcap, rank, price, volume_24h, change_24h, change_7d. Must not be greater than 100 characters.

interval

string optional

24h

Movers window for /coins/gainers and /coins/losers only: 24h or 7d.

One of: 24h 7d

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins?page=1&per_page=50&type=coin&status=active&search=bitcoin&min_price=0.5&max_price=100000&min_marketcap=1000000&max_marketcap=5000000000000&min_volume=1000000&max_volume=100000000000&ids=38%2C39&slugs=bitcoin%2Cethereum&symbols=BTC%2CETH&sort=-marketcap&interval=24h" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins"
);

const params = {
    "page": "1",
    "per_page": "50",
    "type": "coin",
    "status": "active",
    "search": "bitcoin",
    "min_price": "0.5",
    "max_price": "100000",
    "min_marketcap": "1000000",
    "max_marketcap": "5000000000000",
    "min_volume": "1000000",
    "max_volume": "100000000000",
    "ids": "38,39",
    "slugs": "bitcoin,ethereum",
    "symbols": "BTC,ETH",
    "sort": "-marketcap",
    "interval": "24h",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'type' => 'coin',
            'status' => 'active',
            'search' => 'bitcoin',
            'min_price' => '0.5',
            'max_price' => '100000',
            'min_marketcap' => '1000000',
            'max_marketcap' => '5000000000000',
            'min_volume' => '1000000',
            'max_volume' => '100000000000',
            'ids' => '38,39',
            'slugs' => 'bitcoin,ethereum',
            'symbols' => 'BTC,ETH',
            'sort' => '-marketcap',
            'interval' => '24h',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins'
params = {
  'page': '1',
  'per_page': '50',
  'type': 'coin',
  'status': 'active',
  'search': 'bitcoin',
  'min_price': '0.5',
  'max_price': '100000',
  'min_marketcap': '1000000',
  'max_marketcap': '5000000000000',
  'min_volume': '1000000',
  'max_volume': '100000000000',
  'ids': '38,39',
  'slugs': 'bitcoin,ethereum',
  'symbols': 'BTC,ETH',
  'sort': '-marketcap',
  'interval': '24h',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "id": 38,
5            "slug": "bitcoin",
6            "name": "Bitcoin",
7            "symbol": "BTC",
8            "rank": 1,
9            "price": "63520.780763913",
10            "marketcap": 1264646594448.5,
11            "volume_24h": 5345161962,
12            "change_24h": 1.35,
13            "change_7d": 4.98,
14            "change_rank_24h": 0,
15            "change_rank_7d": 0,
16            "circulating_supply": "19909179",
17            "logo": "https://bitculator.com/storage/media/logo/bitcoin.png",
18            "listed_at": "2025-03-15T17:00:43+00:00",
19            "last_updated": "2026-06-27T10:34:17+00:00"
20        }
21    ],
22    "links": {
23        "first": "https://bitculator.com/api/v1/coins?page=1",
24        "last": "https://bitculator.com/api/v1/coins?page=3",
25        "prev": null,
26        "next": "https://bitculator.com/api/v1/coins?page=2"
27    },
28    "meta": {
29        "current_page": 1,
30        "from": 1,
31        "last_page": 3,
32        "per_page": 50,
33        "to": 50,
34        "total": 134
35    }
36}

1{
2    "error": {
3        "code": "validation",
4        "message": "The request parameters are invalid.",
5        "details": {
6            "errors": {
7                "per_page": [
8                    "The per page must not be greater than 250."
9                ]
10            }
11        }
12    }
13}

Recently added coins

Newest listings — sorted by status_updated_at (the went-active timestamp; created_at is the crawl date, which predates listing by arbitrary amounts). Same row shape and pagination envelope as List coins.

GET

http://localhost/api/v1/coins/recently-added

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

type

string optional

coin

Restrict to a single asset type: coin or token.

One of: coin token

status

string optional

active

Listing status: active, delisted, untracked, progressing, awaiting or preparing. Defaults to all public statuses.

One of: active delisted untracked progressing awaiting preparing

search

string optional

bitcoin

Free-text match on name or symbol. Must not be greater than 100 characters.

min_price

number optional

0.5

Only coins priced at or above this USD value. Must be at least 0.

max_price

number optional

100000

Only coins priced at or below this USD value. Must be at least 0.

min_marketcap

number optional

1000000

Only coins with a USD marketcap at or above this value. Must be at least 0.

max_marketcap

number optional

5000000000000

Only coins with a USD marketcap at or below this value. Must be at least 0.

min_volume

number optional

1000000

Only coins with 24h USD volume at or above this value. Must be at least 0.

max_volume

number optional

100000000000

Only coins with 24h USD volume at or below this value. Must be at least 0.

ids

string optional

38,39

Filter to specific coin ids (CSV, up to 100 selectors combined with slugs/symbols). Must not be greater than 1000 characters.

slugs

string optional

bitcoin,ethereum

Filter to specific coin slugs (CSV, up to 100 selectors combined). Must not be greater than 2000 characters.

symbols

string optional

BTC,ETH

Filter to specific coin symbols (CSV, case-insensitive, up to 100 selectors combined). Must not be greater than 1000 characters.

sort

string optional

-marketcap

Comma-separated sort fields; prefix with - for descending. Sortable: marketcap, rank, price, volume_24h, change_24h, change_7d. Must not be greater than 100 characters.

interval

string optional

24h

Movers window for /coins/gainers and /coins/losers only: 24h or 7d.

One of: 24h 7d

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/recently-added?page=1&per_page=50&type=coin&status=active&search=bitcoin&min_price=0.5&max_price=100000&min_marketcap=1000000&max_marketcap=5000000000000&min_volume=1000000&max_volume=100000000000&ids=38%2C39&slugs=bitcoin%2Cethereum&symbols=BTC%2CETH&sort=-marketcap&interval=24h" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/recently-added"
);

const params = {
    "page": "1",
    "per_page": "50",
    "type": "coin",
    "status": "active",
    "search": "bitcoin",
    "min_price": "0.5",
    "max_price": "100000",
    "min_marketcap": "1000000",
    "max_marketcap": "5000000000000",
    "min_volume": "1000000",
    "max_volume": "100000000000",
    "ids": "38,39",
    "slugs": "bitcoin,ethereum",
    "symbols": "BTC,ETH",
    "sort": "-marketcap",
    "interval": "24h",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/recently-added';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'type' => 'coin',
            'status' => 'active',
            'search' => 'bitcoin',
            'min_price' => '0.5',
            'max_price' => '100000',
            'min_marketcap' => '1000000',
            'max_marketcap' => '5000000000000',
            'min_volume' => '1000000',
            'max_volume' => '100000000000',
            'ids' => '38,39',
            'slugs' => 'bitcoin,ethereum',
            'symbols' => 'BTC,ETH',
            'sort' => '-marketcap',
            'interval' => '24h',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/recently-added'
params = {
  'page': '1',
  'per_page': '50',
  'type': 'coin',
  'status': 'active',
  'search': 'bitcoin',
  'min_price': '0.5',
  'max_price': '100000',
  'min_marketcap': '1000000',
  'max_marketcap': '5000000000000',
  'min_volume': '1000000',
  'max_volume': '100000000000',
  'ids': '38,39',
  'slugs': 'bitcoin,ethereum',
  'symbols': 'BTC,ETH',
  'sort': '-marketcap',
  'interval': '24h',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Top gainers

Biggest positive movers over the interval window (24h default, or 7d). Same row shape and pagination envelope as List coins.

GET

http://localhost/api/v1/coins/gainers

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

type

string optional

coin

Restrict to a single asset type: coin or token.

One of: coin token

status

string optional

active

Listing status: active, delisted, untracked, progressing, awaiting or preparing. Defaults to all public statuses.

One of: active delisted untracked progressing awaiting preparing

search

string optional

bitcoin

Free-text match on name or symbol. Must not be greater than 100 characters.

min_price

number optional

0.5

Only coins priced at or above this USD value. Must be at least 0.

max_price

number optional

100000

Only coins priced at or below this USD value. Must be at least 0.

min_marketcap

number optional

1000000

Only coins with a USD marketcap at or above this value. Must be at least 0.

max_marketcap

number optional

5000000000000

Only coins with a USD marketcap at or below this value. Must be at least 0.

min_volume

number optional

1000000

Only coins with 24h USD volume at or above this value. Must be at least 0.

max_volume

number optional

100000000000

Only coins with 24h USD volume at or below this value. Must be at least 0.

ids

string optional

38,39

Filter to specific coin ids (CSV, up to 100 selectors combined with slugs/symbols). Must not be greater than 1000 characters.

slugs

string optional

bitcoin,ethereum

Filter to specific coin slugs (CSV, up to 100 selectors combined). Must not be greater than 2000 characters.

symbols

string optional

BTC,ETH

Filter to specific coin symbols (CSV, case-insensitive, up to 100 selectors combined). Must not be greater than 1000 characters.

sort

string optional

-marketcap

Comma-separated sort fields; prefix with - for descending. Sortable: marketcap, rank, price, volume_24h, change_24h, change_7d. Must not be greater than 100 characters.

interval

string optional

24h

Movers window for /coins/gainers and /coins/losers only: 24h or 7d.

One of: 24h 7d

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/gainers?page=1&per_page=50&type=coin&status=active&search=bitcoin&min_price=0.5&max_price=100000&min_marketcap=1000000&max_marketcap=5000000000000&min_volume=1000000&max_volume=100000000000&ids=38%2C39&slugs=bitcoin%2Cethereum&symbols=BTC%2CETH&sort=-marketcap&interval=24h" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/gainers"
);

const params = {
    "page": "1",
    "per_page": "50",
    "type": "coin",
    "status": "active",
    "search": "bitcoin",
    "min_price": "0.5",
    "max_price": "100000",
    "min_marketcap": "1000000",
    "max_marketcap": "5000000000000",
    "min_volume": "1000000",
    "max_volume": "100000000000",
    "ids": "38,39",
    "slugs": "bitcoin,ethereum",
    "symbols": "BTC,ETH",
    "sort": "-marketcap",
    "interval": "24h",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/gainers';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'type' => 'coin',
            'status' => 'active',
            'search' => 'bitcoin',
            'min_price' => '0.5',
            'max_price' => '100000',
            'min_marketcap' => '1000000',
            'max_marketcap' => '5000000000000',
            'min_volume' => '1000000',
            'max_volume' => '100000000000',
            'ids' => '38,39',
            'slugs' => 'bitcoin,ethereum',
            'symbols' => 'BTC,ETH',
            'sort' => '-marketcap',
            'interval' => '24h',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/gainers'
params = {
  'page': '1',
  'per_page': '50',
  'type': 'coin',
  'status': 'active',
  'search': 'bitcoin',
  'min_price': '0.5',
  'max_price': '100000',
  'min_marketcap': '1000000',
  'max_marketcap': '5000000000000',
  'min_volume': '1000000',
  'max_volume': '100000000000',
  'ids': '38,39',
  'slugs': 'bitcoin,ethereum',
  'symbols': 'BTC,ETH',
  'sort': '-marketcap',
  'interval': '24h',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "id": 38,
5            "slug": "bitcoin",
6            "name": "Bitcoin",
7            "symbol": "BTC",
8            "rank": 1,
9            "price": "63520.780763913",
10            "marketcap": 1264646594448.5,
11            "volume_24h": 5345161962,
12            "change_24h": 1.35,
13            "change_7d": 4.98,
14            "change_rank_24h": 0,
15            "change_rank_7d": 0,
16            "circulating_supply": "19909179",
17            "logo": "https://bitculator.com/storage/media/logo/bitcoin.png",
18            "listed_at": "2025-03-15T17:00:43+00:00",
19            "last_updated": "2026-06-27T10:34:17+00:00"
20        }
21    ],
22    "links": {
23        "first": "https://bitculator.com/api/v1/coins/gainers?page=1",
24        "last": "https://bitculator.com/api/v1/coins/gainers?page=2",
25        "prev": null,
26        "next": "https://bitculator.com/api/v1/coins/gainers?page=2"
27    },
28    "meta": {
29        "current_page": 1,
30        "from": 1,
31        "last_page": 2,
32        "per_page": 50,
33        "to": 50,
34        "total": 89
35    }
36}

Top losers

Biggest negative movers over the interval window (24h default, or 7d). Same row shape and pagination envelope as List coins.

GET

http://localhost/api/v1/coins/losers

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

type

string optional

coin

Restrict to a single asset type: coin or token.

One of: coin token

status

string optional

active

Listing status: active, delisted, untracked, progressing, awaiting or preparing. Defaults to all public statuses.

One of: active delisted untracked progressing awaiting preparing

search

string optional

bitcoin

Free-text match on name or symbol. Must not be greater than 100 characters.

min_price

number optional

0.5

Only coins priced at or above this USD value. Must be at least 0.

max_price

number optional

100000

Only coins priced at or below this USD value. Must be at least 0.

min_marketcap

number optional

1000000

Only coins with a USD marketcap at or above this value. Must be at least 0.

max_marketcap

number optional

5000000000000

Only coins with a USD marketcap at or below this value. Must be at least 0.

min_volume

number optional

1000000

Only coins with 24h USD volume at or above this value. Must be at least 0.

max_volume

number optional

100000000000

Only coins with 24h USD volume at or below this value. Must be at least 0.

ids

string optional

38,39

Filter to specific coin ids (CSV, up to 100 selectors combined with slugs/symbols). Must not be greater than 1000 characters.

slugs

string optional

bitcoin,ethereum

Filter to specific coin slugs (CSV, up to 100 selectors combined). Must not be greater than 2000 characters.

symbols

string optional

BTC,ETH

Filter to specific coin symbols (CSV, case-insensitive, up to 100 selectors combined). Must not be greater than 1000 characters.

sort

string optional

-marketcap

Comma-separated sort fields; prefix with - for descending. Sortable: marketcap, rank, price, volume_24h, change_24h, change_7d. Must not be greater than 100 characters.

interval

string optional

24h

Movers window for /coins/gainers and /coins/losers only: 24h or 7d.

One of: 24h 7d

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/losers?page=1&per_page=50&type=coin&status=active&search=bitcoin&min_price=0.5&max_price=100000&min_marketcap=1000000&max_marketcap=5000000000000&min_volume=1000000&max_volume=100000000000&ids=38%2C39&slugs=bitcoin%2Cethereum&symbols=BTC%2CETH&sort=-marketcap&interval=24h" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/losers"
);

const params = {
    "page": "1",
    "per_page": "50",
    "type": "coin",
    "status": "active",
    "search": "bitcoin",
    "min_price": "0.5",
    "max_price": "100000",
    "min_marketcap": "1000000",
    "max_marketcap": "5000000000000",
    "min_volume": "1000000",
    "max_volume": "100000000000",
    "ids": "38,39",
    "slugs": "bitcoin,ethereum",
    "symbols": "BTC,ETH",
    "sort": "-marketcap",
    "interval": "24h",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/losers';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'type' => 'coin',
            'status' => 'active',
            'search' => 'bitcoin',
            'min_price' => '0.5',
            'max_price' => '100000',
            'min_marketcap' => '1000000',
            'max_marketcap' => '5000000000000',
            'min_volume' => '1000000',
            'max_volume' => '100000000000',
            'ids' => '38,39',
            'slugs' => 'bitcoin,ethereum',
            'symbols' => 'BTC,ETH',
            'sort' => '-marketcap',
            'interval' => '24h',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/losers'
params = {
  'page': '1',
  'per_page': '50',
  'type': 'coin',
  'status': 'active',
  'search': 'bitcoin',
  'min_price': '0.5',
  'max_price': '100000',
  'min_marketcap': '1000000',
  'max_marketcap': '5000000000000',
  'min_volume': '1000000',
  'max_volume': '100000000000',
  'ids': '38,39',
  'slugs': 'bitcoin,ethereum',
  'symbols': 'BTC,ETH',
  'sort': '-marketcap',
  'interval': '24h',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Trending coins

The most-viewed coins right now, ranked by view score. A compact projection (no pagination): id, slug, name, symbol, rank, price (decimal string), marketcap, logo and score.

GET

http://localhost/api/v1/coins/trending

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

limit

integer optional

10

How many trending coins to return (1–20, default 10).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/trending?limit=10" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/trending"
);

const params = {
    "limit": "10",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/trending';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'limit' => '10',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/trending'
params = {
  'limit': '10',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "id": 38,
5            "slug": "bitcoin",
6            "name": "Bitcoin",
7            "symbol": "BTC",
8            "rank": 1,
9            "price": "63520.780763913",
10            "marketcap": 1264646594448.5,
11            "logo": "https://bitculator.com/storage/media/logo/bitcoin.png",
12            "score": 2
13        }
14    ]
15}

Get coin detail

Full single-coin profile. Beyond the list fields it adds: supply (circulating/total/max), today OHLC, all_time_high / all_time_low (price, date and percent_from the current price), fully_diluted_valuation, market counts (exchanges/pairs/tickers/wallets), decimals, genesis_date, official links (typed url list), token contracts, and a localized HTML description (falls back to English when the requested locale is missing). All price/supply fields are decimal strings.

GET

http://localhost/api/v1/coins/{slug}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin slug.

Query parameters

locale

string optional

en

Content language for the description (falls back to English).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/bitcoin?locale=en" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin"
);

const params = {
    "locale": "en",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'locale' => 'en',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin'
params = {
  'locale': 'en',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": {
3        "id": 38,
4        "slug": "bitcoin",
5        "name": "Bitcoin",
6        "symbol": "BTC",
7        "type": "coin",
8        "rank": 1,
9        "price": "63520.780763913",
10        "marketcap": 1264646594448.5,
11        "fully_diluted_valuation": 1333936396042.17,
12        "volume_24h": 5345161962,
13        "change_24h": 1.35,
14        "change_7d": 4.98,
15        "change_rank_24h": 0,
16        "change_rank_7d": 0,
17        "supply": {
18            "circulating": "19909179",
19            "total": "19970852",
20            "max": "21000000"
21        },
22        "today": {
23            "open": "63408.100996475",
24            "high": "63640.608639825",
25            "low": "62798.732107749",
26            "close": "63520.780763913"
27        },
28        "all_time_high": {
29            "price": "125881.21309073",
30            "date": "2025-10-06",
31            "percent_from": -49.54
32        },
33        "all_time_low": {
34            "price": "0.099",
35            "date": "2010-10-12",
36            "percent_from": 64162304.81
37        },
38        "counts": {
39            "exchanges": 11,
40            "pairs": 92,
41            "tickers": 211,
42            "wallets": 206
43        },
44        "decimals": 8,
45        "genesis_date": "2009-01-03",
46        "description": "<p>Bitcoin is a decentralized digital currency…</p>",
47        "links": [
48            {
49                "type": "website",
50                "url": "https://bitcoin.org/en/"
51            },
52            {
53                "type": "whitepaper",
54                "url": "https://bitcoin.org/bitcoin.pdf"
55            }
56        ],
57        "contracts": [],
58        "logo": "https://bitculator.com/storage/media/logo/bitcoin.png",
59        "last_updated": "2026-06-27T10:34:17+00:00"
60    }
61}

1{
2    "error": {
3        "code": "not_found",
4        "message": "Coin not found."
5    }
6}

Candle history

Per-coin OHLC + volume + marketcap time series. Pick interval: minutely, half-hourly, hourly or daily. Retention is a hard property of the rollup pipeline — minutely 8 days, half-hourly 3 months, hourly 6 months, daily forever; requests beyond a window return what exists. When a limit is set you get the MOST RECENT N rows in the window, emitted oldest-first. Prices are decimal strings.

GET

http://localhost/api/v1/coins/{slug}/history

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin slug.

Query parameters

interval

string optional

daily

minutely, half-hourly, hourly or daily (default daily).

start

string optional

2026-06-01

ISO date/time lower bound.

end

string optional

2026-06-30

ISO date/time upper bound (a date-only value means through that day).

limit

integer optional

30

Max rows (1–2000, default 1000).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/bitcoin/history?interval=daily&start=2026-06-01&end=2026-06-30&limit=30" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin/history"
);

const params = {
    "interval": "daily",
    "start": "2026-06-01",
    "end": "2026-06-30",
    "limit": "30",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin/history';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'interval' => 'daily',
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin/history'
params = {
  'interval': 'daily',
  'start': '2026-06-01',
  'end': '2026-06-30',
  'limit': '30',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "time": "2026-06-14T23:01:01+00:00",
5            "price": "65481.259006434",
6            "open": "64193.294621057",
7            "high": "65513.599862059",
8            "low": "63528.138075558",
9            "close": "65481.259006434",
10            "volume_24h": 3795657715,
11            "marketcap": 1303678106704.5
12        }
13    ],
14    "meta": {
15        "coin": "bitcoin",
16        "interval": "daily",
17        "count": 1,
18        "retention": "full history"
19    }
20}

1{
2    "error": {
3        "code": "not_found",
4        "message": "Coin not found."
5    }
6}

Marketcap history

The same per-coin rollups as Candle history, projected to {time, marketcap} only. Same interval choices and retention windows (minutely 8 days, half-hourly 3 months, hourly 6 months, daily forever), most-recent-N when a limit is set.

GET

http://localhost/api/v1/coins/{slug}/marketcap-history

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin slug.

Query parameters

interval

string optional

daily

minutely, half-hourly, hourly or daily (default daily).

start

string optional

2026-06-01

ISO date/time lower bound.

end

string optional

2026-06-30

ISO date/time upper bound.

limit

integer optional

30

Max rows (1–2000, default 1000).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/bitcoin/marketcap-history?interval=daily&start=2026-06-01&end=2026-06-30&limit=30" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin/marketcap-history"
);

const params = {
    "interval": "daily",
    "start": "2026-06-01",
    "end": "2026-06-30",
    "limit": "30",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin/marketcap-history';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'interval' => 'daily',
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin/marketcap-history'
params = {
  'interval': 'daily',
  'start': '2026-06-01',
  'end': '2026-06-30',
  'limit': '30',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Coin sparkline

A compact price series for the coin over the chosen period, for drawing sparklines.

GET

http://localhost/api/v1/coins/{slug}/sparkline

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin slug.

Query parameters

period

string optional

7d

24h, 7d, 30d, 60d, 90d, 180d or 365d (default 7d).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/bitcoin/sparkline?period=7d" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin/sparkline"
);

const params = {
    "period": "7d",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin/sparkline';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'period' => '7d',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin/sparkline'
params = {
  'period': '7d',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get prices

Prices for a requested set of coins. Pass at least one selector — ids, slugs or symbols (up to 100 combined). meta.currency echoes the conversion target (USD unless convert is set).

GET

http://localhost/api/v1/prices

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

ids

string optional

38,39

Coin ids to price (CSV). At least one of ids, slugs or symbols is required; the three lists cap at 100 selectors combined. This field is required when none of slugs and symbols are present. Must not be greater than 1000 characters.

slugs

string optional

bitcoin,ethereum

Coin slugs to price (CSV). At least one of ids, slugs or symbols is required. This field is required when none of ids and symbols are present. Must not be greater than 2000 characters.

symbols

string optional

BTC,ETH

Coin symbols to price (CSV, case-insensitive). At least one of ids, slugs or symbols is required. This field is required when none of ids and slugs are present. Must not be greater than 1000 characters.

convert

string optional

EUR

Convert prices/marketcap into an active fiat currency by symbol (default USD). FX rates refresh ~twice daily.

One of: USD EUR JPY BGN CZK DKK GBP HUF PLN RON SEK CHF ISK NOK HRK RUB TRY AUD BRL CAD CNY HKD IDR ILS INR KRW MXN MYR NZD PHP SGD THB ZAR ARS DZD MAD TWD

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/prices?ids=38%2C39&slugs=bitcoin%2Cethereum&symbols=BTC%2CETH&convert=EUR" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/prices"
);

const params = {
    "ids": "38,39",
    "slugs": "bitcoin,ethereum",
    "symbols": "BTC,ETH",
    "convert": "EUR",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/prices';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'ids' => '38,39',
            'slugs' => 'bitcoin,ethereum',
            'symbols' => 'BTC,ETH',
            'convert' => 'EUR',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/prices'
params = {
  'ids': '38,39',
  'slugs': 'bitcoin,ethereum',
  'symbols': 'BTC,ETH',
  'convert': 'EUR',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "id": 38,
5            "slug": "bitcoin",
6            "symbol": "BTC",
7            "name": "Bitcoin",
8            "rank": 1,
9            "price": "63520.780763913",
10            "marketcap": 1264646594448.5,
11            "volume_24h": 5345161962,
12            "change_24h": 1.35,
13            "change_7d": 4.98,
14            "change_rank_24h": 0,
15            "change_rank_7d": 0,
16            "last_updated": "2026-06-27T10:34:17+00:00"
17        },
18        {
19            "id": 39,
20            "slug": "ethereum",
21            "symbol": "ETH",
22            "name": "Ethereum",
23            "rank": 2,
24            "price": "1672.4623100248",
25            "marketcap": 203243220990.49,
26            "volume_24h": 69585141532,
27            "change_24h": 1.42,
28            "change_7d": 7.56,
29            "change_rank_24h": 0,
30            "change_rank_7d": 0,
31            "last_updated": "2026-06-12T09:32:14+00:00"
32        }
33    ],
34    "meta": {
35        "currency": "USD",
36        "count": 2
37    }
38}

1{
2    "error": {
3        "code": "validation",
4        "message": "The request parameters are invalid.",
5        "details": {
6            "errors": {
7                "ids": [
8                    "Pass at least one selector: ids, slugs or symbols."
9                ]
10            }
11        }
12    }
13}

Get a coin price

Single-coin price snapshot. Optionally convert into an active fiat currency by symbol (default USD).

GET

http://localhost/api/v1/prices/{slug}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin slug.

Query parameters

convert

string optional

EUR

Active fiat currency symbol to price in (default USD).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/prices/bitcoin?convert=EUR" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/prices/bitcoin"
);

const params = {
    "convert": "EUR",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/prices/bitcoin';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'convert' => 'EUR',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/prices/bitcoin'
params = {
  'convert': 'EUR',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": {
3        "id": 38,
4        "slug": "bitcoin",
5        "symbol": "BTC",
6        "name": "Bitcoin",
7        "rank": 1,
8        "price": "63520.780763913",
9        "marketcap": 1264646594448.5,
10        "volume_24h": 5345161962,
11        "change_24h": 1.35,
12        "change_7d": 4.98,
13        "change_rank_24h": 0,
14        "change_rank_7d": 0,
15        "last_updated": "2026-06-27T10:34:17+00:00"
16    },
17    "meta": {
18        "currency": "USD",
19        "count": 1
20    }
21}

1{
2    "error": {
3        "code": "not_found",
4        "message": "Coin not found."
5    }
6}

Historical price

The coin's USD price on a given date, read from the daily history (exact day, ±3-day fallback — the same resolver the portfolio uses). Crypto only: fiat rows have no daily history.

GET

http://localhost/api/v1/historical-price

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

slug

string required

bitcoin

The coin's slug identifier.

date

string required

2021-04-14

date The lookup date (after 2008-12-31, not in the future).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/historical-price?slug=bitcoin&date=2021-04-14" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/historical-price"
);

const params = {
    "slug": "bitcoin",
    "date": "2021-04-14",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/historical-price';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'slug' => 'bitcoin',
            'date' => '2021-04-14',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/historical-price'
params = {
  'slug': 'bitcoin',
  'date': '2021-04-14',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": {
3        "slug": "bitcoin",
4        "symbol": "BTC",
5        "date": "2021-04-14",
6        "price": "63109.7",
7        "currency": "USD"
8    }
9}

Coin markets

All markets for a coin — the tickers whose pair has the coin as base OR quote. Same row shape and filters as List tickers.

GET

http://localhost/api/v1/coins/{slug}/markets

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin slug.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

exchange

string optional

binance-exchange

Restrict to a single exchange by slug (omit on the per-exchange listing, which is already scoped). Must match the regex /^[a-z0-9-]{1,120}$/.

pair

integer optional

1

Restrict to a single pair by id. Must be at least 1.

instrument

string optional

spot

Instrument type: future, option, swap, spot or margin (plurals accepted).

One of: future option swap spot margin

search

string optional

BTC

Free-text match on the ticker symbol. Must not be greater than 50 characters.

min_volume

number optional

1000000

Only tickers with 24h USD volume at or above this value. Must be at least 0.

max_volume

number optional

100000000000

Only tickers with 24h USD volume at or below this value. Must be at least 0.

min_change

number optional

-50

Only tickers with a 24h percentage change at or above this value.

max_change

number optional

50

Only tickers with a 24h percentage change at or below this value.

sort

string optional

-volume_usd

A single sort field (prefix with - for descending). Sortable: volume_usd, change_24h, price_usd, updated. Defaults to -volume_usd. Must not be greater than 100 characters.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/bitcoin/markets?page=1&per_page=50&exchange=binance-exchange&pair=1&instrument=spot&search=BTC&min_volume=1000000&max_volume=100000000000&min_change=-50&max_change=50&sort=-volume_usd" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin/markets"
);

const params = {
    "page": "1",
    "per_page": "50",
    "exchange": "binance-exchange",
    "pair": "1",
    "instrument": "spot",
    "search": "BTC",
    "min_volume": "1000000",
    "max_volume": "100000000000",
    "min_change": "-50",
    "max_change": "50",
    "sort": "-volume_usd",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin/markets';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'exchange' => 'binance-exchange',
            'pair' => '1',
            'instrument' => 'spot',
            'search' => 'BTC',
            'min_volume' => '1000000',
            'max_volume' => '100000000000',
            'min_change' => '-50',
            'max_change' => '50',
            'sort' => '-volume_usd',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin/markets'
params = {
  'page': '1',
  'per_page': '50',
  'exchange': 'binance-exchange',
  'pair': '1',
  'instrument': 'spot',
  'search': 'BTC',
  'min_volume': '1000000',
  'max_volume': '100000000000',
  'min_change': '-50',
  'max_change': '50',
  'sort': '-volume_usd',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Coin trading symbols

The coin's raw per-exchange trading symbols — sparsely populated reference data (coverage is best-effort).

GET

http://localhost/api/v1/coins/{slug}/symbols

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin slug.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/bitcoin/symbols" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin/symbols"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin/symbols';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin/symbols'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List tickers

Individual per-exchange markets (tickers), paginated. Filter by exchange, pair, instrument and volume/change ranges. USD volumes are numbers; prices are decimal strings.

GET

http://localhost/api/v1/tickers

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

exchange

string optional

binance-exchange

Restrict to a single exchange by slug (omit on the per-exchange listing, which is already scoped). Must match the regex /^[a-z0-9-]{1,120}$/.

pair

integer optional

1

Restrict to a single pair by id. Must be at least 1.

instrument

string optional

spot

Instrument type: future, option, swap, spot or margin (plurals accepted).

One of: future option swap spot margin

search

string optional

BTC

Free-text match on the ticker symbol. Must not be greater than 50 characters.

min_volume

number optional

1000000

Only tickers with 24h USD volume at or above this value. Must be at least 0.

max_volume

number optional

100000000000

Only tickers with 24h USD volume at or below this value. Must be at least 0.

min_change

number optional

-50

Only tickers with a 24h percentage change at or above this value.

max_change

number optional

50

Only tickers with a 24h percentage change at or below this value.

sort

string optional

-volume_usd

A single sort field (prefix with - for descending). Sortable: volume_usd, change_24h, price_usd, updated. Defaults to -volume_usd. Must not be greater than 100 characters.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/tickers?page=1&per_page=50&exchange=binance-exchange&pair=1&instrument=spot&search=BTC&min_volume=1000000&max_volume=100000000000&min_change=-50&max_change=50&sort=-volume_usd" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/tickers"
);

const params = {
    "page": "1",
    "per_page": "50",
    "exchange": "binance-exchange",
    "pair": "1",
    "instrument": "spot",
    "search": "BTC",
    "min_volume": "1000000",
    "max_volume": "100000000000",
    "min_change": "-50",
    "max_change": "50",
    "sort": "-volume_usd",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/tickers';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'exchange' => 'binance-exchange',
            'pair' => '1',
            'instrument' => 'spot',
            'search' => 'BTC',
            'min_volume' => '1000000',
            'max_volume' => '100000000000',
            'min_change' => '-50',
            'max_change' => '50',
            'sort' => '-volume_usd',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/tickers'
params = {
  'page': '1',
  'per_page': '50',
  'exchange': 'binance-exchange',
  'pair': '1',
  'instrument': 'spot',
  'search': 'BTC',
  'min_volume': '1000000',
  'max_volume': '100000000000',
  'min_change': '-50',
  'max_change': '50',
  'sort': '-volume_usd',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List pairs

Venue-aggregated trading pairs, ranked by 24h USD volume. Filter by a coin slug (base or quote) and volume range.

GET

http://localhost/api/v1/pairs

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

search

string optional

BTC

Free-text match on the pair symbol. Must not be greater than 50 characters.

coin

string optional

bitcoin

Restrict to pairs where this coin slug is the base or quote asset. Must match the regex /^[a-z0-9-]{1,120}$/.

min_volume

number optional

1000000

Only pairs with 24h USD volume at or above this value. Must be at least 0.

max_volume

number optional

100000000000

Only pairs with 24h USD volume at or below this value. Must be at least 0.

sort

string optional

-volume_usd

Sort field: volume_usd or updated (prefix with - for descending). Defaults to -volume_usd.

One of: volume_usd -volume_usd updated -updated

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/pairs?page=1&per_page=50&search=BTC&coin=bitcoin&min_volume=1000000&max_volume=100000000000&sort=-volume_usd" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/pairs"
);

const params = {
    "page": "1",
    "per_page": "50",
    "search": "BTC",
    "coin": "bitcoin",
    "min_volume": "1000000",
    "max_volume": "100000000000",
    "sort": "-volume_usd",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/pairs';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'search' => 'BTC',
            'coin' => 'bitcoin',
            'min_volume' => '1000000',
            'max_volume' => '100000000000',
            'sort' => '-volume_usd',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/pairs'
params = {
  'page': '1',
  'per_page': '50',
  'search': 'BTC',
  'coin': 'bitcoin',
  'min_volume': '1000000',
  'max_volume': '100000000000',
  'sort': '-volume_usd',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get pair detail

One pair plus every exchange ticker listing it, ordered by volume.

GET

http://localhost/api/v1/pairs/{id}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

id

integer required

1

The pair id.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/pairs/1" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/pairs/1"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/pairs/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/pairs/1'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "error": {
3        "code": "not_found",
4        "message": "Pair not found."
5    }
6}

List exchanges

Ranked exchanges with 24h volume, dominance, pair/asset counts and recent changes. Paginated with Laravel's links + meta envelope.

GET

http://localhost/api/v1/exchanges

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

type

string optional

cex

Restrict to a venue type: cex or dex (resolved via the exchange taxonomy).

One of: cex dex

search

string optional

binance

Free-text match on exchange name. Must not be greater than 100 characters.

min_pairs

integer optional

100

Only exchanges listing at least this many pairs. Must be at least 0.

max_pairs

integer optional

2000

Only exchanges listing at most this many pairs. Must be at least 0.

min_assets

integer optional

50

Only exchanges listing at least this many assets. Must be at least 0.

max_assets

integer optional

1000

Only exchanges listing at most this many assets. Must be at least 0.

min_volume

number optional

1000000

Only exchanges with 24h USD volume at or above this value. Must be at least 0.

max_volume

number optional

100000000000

Only exchanges with 24h USD volume at or below this value. Must be at least 0.

ids

string optional

1,12

Filter to specific exchange ids (CSV, up to 100). Must not be greater than 1000 characters.

slugs

string optional

binance-exchange,gateio

Filter to specific exchange slugs (CSV, up to 100). Must not be greater than 2000 characters.

sort

string optional

-volume

Comma-separated sort fields; prefix with - for descending. Sortable: volume, rank, volume_dominance, change_24h, change_7d, pairs, assets. Must not be greater than 100 characters.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/exchanges?page=1&per_page=50&type=cex&search=binance&min_pairs=100&max_pairs=2000&min_assets=50&max_assets=1000&min_volume=1000000&max_volume=100000000000&ids=1%2C12&slugs=binance-exchange%2Cgateio&sort=-volume" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/exchanges"
);

const params = {
    "page": "1",
    "per_page": "50",
    "type": "cex",
    "search": "binance",
    "min_pairs": "100",
    "max_pairs": "2000",
    "min_assets": "50",
    "max_assets": "1000",
    "min_volume": "1000000",
    "max_volume": "100000000000",
    "ids": "1,12",
    "slugs": "binance-exchange,gateio",
    "sort": "-volume",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/exchanges';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'type' => 'cex',
            'search' => 'binance',
            'min_pairs' => '100',
            'max_pairs' => '2000',
            'min_assets' => '50',
            'max_assets' => '1000',
            'min_volume' => '1000000',
            'max_volume' => '100000000000',
            'ids' => '1,12',
            'slugs' => 'binance-exchange,gateio',
            'sort' => '-volume',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/exchanges'
params = {
  'page': '1',
  'per_page': '50',
  'type': 'cex',
  'search': 'binance',
  'min_pairs': '100',
  'max_pairs': '2000',
  'min_assets': '50',
  'max_assets': '1000',
  'min_volume': '1000000',
  'max_volume': '100000000000',
  'ids': '1,12',
  'slugs': 'binance-exchange,gateio',
  'sort': '-volume',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "id": 1,
5            "slug": "binance-exchange",
6            "name": "Binance",
7            "rank": 1,
8            "volume_24h": 6152385798,
9            "volume_dominance": 36.98,
10            "change_24h": 200.09,
11            "change_7d": 22.87,
12            "change_rank_24h": 0,
13            "change_rank_7d": 0,
14            "pairs": 1115,
15            "assets": 100,
16            "logo": "https://bitculator.com/storage/media/logo/binance.png",
17            "last_updated": "2026-06-15T16:59:21+00:00"
18        }
19    ],
20    "links": {
21        "first": "https://bitculator.com/api/v1/exchanges?page=1",
22        "last": "https://bitculator.com/api/v1/exchanges?page=1",
23        "prev": null,
24        "next": null
25    },
26    "meta": {
27        "current_page": 1,
28        "from": 1,
29        "last_page": 1,
30        "per_page": 50,
31        "to": 10,
32        "total": 10
33    }
34}

Get exchange detail

Full single-exchange profile: ranking, volume/dominance, pair and asset counts, established date, location, referral website, and the derived type (cex/dex/null).

GET

http://localhost/api/v1/exchanges/{slug}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

binance-exchange

The exchange slug.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/exchanges/binance-exchange" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/exchanges/binance-exchange"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/exchanges/binance-exchange';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/exchanges/binance-exchange'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "data": {
3        "id": 1,
4        "slug": "binance-exchange",
5        "name": "Binance",
6        "type": "cex",
7        "rank": 1,
8        "volume_24h": 6152385798,
9        "volume_dominance": 36.98,
10        "change_24h": 200.09,
11        "change_7d": 22.87,
12        "change_rank_24h": 0,
13        "change_rank_7d": 0,
14        "pairs": 1115,
15        "assets": 100,
16        "established": "2017-07-14",
17        "location": "Cayman Islands",
18        "website": "https://accounts.binance.com/register",
19        "logo": "https://bitculator.com/storage/media/logo/binance.png",
20        "last_updated": "2026-06-15T16:59:21+00:00"
21    }
22}

1{
2    "error": {
3        "code": "not_found",
4        "message": "Exchange not found."
5    }
6}

Get exchange trust score

An aggregate 0–10 trust score plus its 13-factor breakdown (rank, volume, age, volume_trend, stability, rank_stability, ticker_health, pairs, community, assets, dominance, market_breadth, transparency). Computed per exchange and cached 24h.

GET

http://localhost/api/v1/exchanges/{slug}/trust-score

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

binance-exchange

The exchange slug.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/exchanges/binance-exchange/trust-score" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/exchanges/binance-exchange/trust-score"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/exchanges/binance-exchange/trust-score';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/exchanges/binance-exchange/trust-score'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "data": {
3        "exchange": "binance-exchange",
4        "score": 8.3,
5        "breakdown": {
6            "rank": 10,
7            "volume": 10,
8            "age": 10,
9            "volume_trend": 7,
10            "stability": 3,
11            "rank_stability": 10,
12            "ticker_health": 8.6,
13            "pairs": 9.6,
14            "community": 6,
15            "assets": 6.6,
16            "dominance": 9.4,
17            "market_breadth": 8,
18            "transparency": 8.5
19        }
20    }
21}

1{
2    "error": {
3        "code": "not_found",
4        "message": "Exchange not found."
5    }
6}

Exchange history

Volume / dominance / pairs / assets time series (the exchange rollups carry no OHLC). Pick interval: minutely, hourly or daily. Retention is a hard property of the rollup pipeline — minutely 8 days, hourly 6 months, daily forever; when a limit is set you get the most-recent N rows in the window, oldest-first.

GET

http://localhost/api/v1/exchanges/{slug}/history

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

binance-exchange

The exchange slug.

Query parameters

interval

string optional

daily

minutely, hourly or daily (default daily).

start

string optional

2026-06-01

ISO date/time lower bound.

end

string optional

2026-06-30

ISO date/time upper bound (a date-only value means through that day).

limit

integer optional

30

Max rows (1–2000, default 1000).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/exchanges/binance-exchange/history?interval=daily&start=2026-06-01&end=2026-06-30&limit=30" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/exchanges/binance-exchange/history"
);

const params = {
    "interval": "daily",
    "start": "2026-06-01",
    "end": "2026-06-30",
    "limit": "30",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/exchanges/binance-exchange/history';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'interval' => 'daily',
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/exchanges/binance-exchange/history'
params = {
  'interval': 'daily',
  'start': '2026-06-01',
  'end': '2026-06-30',
  'limit': '30',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Exchange sparkline

The exchange's volume sparkline series for a period (defaults to 7d) — the same series the web's exchange rows render.

GET

http://localhost/api/v1/exchanges/{slug}/sparkline

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

binance-exchange

The exchange slug.

Query parameters

period

string optional

7d

One of 24h, 7d (default), 30d, 60d, 90d, 180d, 365d.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/exchanges/binance-exchange/sparkline?period=7d" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/exchanges/binance-exchange/sparkline"
);

const params = {
    "period": "7d",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/exchanges/binance-exchange/sparkline';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'period' => '7d',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/exchanges/binance-exchange/sparkline'
params = {
  'period': '7d',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Exchange markets

The exchange's ticker listings (its markets), paginated. Already scoped to the exchange — do not pass an exchange parameter here.

GET

http://localhost/api/v1/exchanges/{slug}/tickers

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

binance-exchange

The exchange slug.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

exchange

string optional

binance-exchange

Restrict to a single exchange by slug (omit on the per-exchange listing, which is already scoped). Must match the regex /^[a-z0-9-]{1,120}$/.

pair

integer optional

1

Restrict to a single pair by id. Must be at least 1.

instrument

string optional

spot

Instrument type: future, option, swap, spot or margin (plurals accepted).

One of: future option swap spot margin

search

string optional

BTC

Free-text match on the ticker symbol. Must not be greater than 50 characters.

min_volume

number optional

1000000

Only tickers with 24h USD volume at or above this value. Must be at least 0.

max_volume

number optional

100000000000

Only tickers with 24h USD volume at or below this value. Must be at least 0.

min_change

number optional

-50

Only tickers with a 24h percentage change at or above this value.

max_change

number optional

50

Only tickers with a 24h percentage change at or below this value.

sort

string optional

-volume_usd

A single sort field (prefix with - for descending). Sortable: volume_usd, change_24h, price_usd, updated. Defaults to -volume_usd. Must not be greater than 100 characters.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/exchanges/binance-exchange/tickers?page=1&per_page=50&exchange=binance-exchange&pair=1&instrument=spot&search=BTC&min_volume=1000000&max_volume=100000000000&min_change=-50&max_change=50&sort=-volume_usd" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/exchanges/binance-exchange/tickers"
);

const params = {
    "page": "1",
    "per_page": "50",
    "exchange": "binance-exchange",
    "pair": "1",
    "instrument": "spot",
    "search": "BTC",
    "min_volume": "1000000",
    "max_volume": "100000000000",
    "min_change": "-50",
    "max_change": "50",
    "sort": "-volume_usd",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/exchanges/binance-exchange/tickers';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'exchange' => 'binance-exchange',
            'pair' => '1',
            'instrument' => 'spot',
            'search' => 'BTC',
            'min_volume' => '1000000',
            'max_volume' => '100000000000',
            'min_change' => '-50',
            'max_change' => '50',
            'sort' => '-volume_usd',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/exchanges/binance-exchange/tickers'
params = {
  'page': '1',
  'per_page': '50',
  'exchange': 'binance-exchange',
  'pair': '1',
  'instrument': 'spot',
  'search': 'BTC',
  'min_volume': '1000000',
  'max_volume': '100000000000',
  'min_change': '-50',
  'max_change': '50',
  'sort': '-volume_usd',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Exchange coins

Coins listed on the exchange, returned in the same shape as List coins and accepting the same filters/sort.

GET

http://localhost/api/v1/exchanges/{slug}/assets

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

binance-exchange

The exchange slug.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

type

string optional

coin

Restrict to a single asset type: coin or token.

One of: coin token

status

string optional

active

Listing status: active, delisted, untracked, progressing, awaiting or preparing. Defaults to all public statuses.

One of: active delisted untracked progressing awaiting preparing

search

string optional

bitcoin

Free-text match on name or symbol. Must not be greater than 100 characters.

min_price

number optional

0.5

Only coins priced at or above this USD value. Must be at least 0.

max_price

number optional

100000

Only coins priced at or below this USD value. Must be at least 0.

min_marketcap

number optional

1000000

Only coins with a USD marketcap at or above this value. Must be at least 0.

max_marketcap

number optional

5000000000000

Only coins with a USD marketcap at or below this value. Must be at least 0.

min_volume

number optional

1000000

Only coins with 24h USD volume at or above this value. Must be at least 0.

max_volume

number optional

100000000000

Only coins with 24h USD volume at or below this value. Must be at least 0.

ids

string optional

38,39

Filter to specific coin ids (CSV, up to 100 selectors combined with slugs/symbols). Must not be greater than 1000 characters.

slugs

string optional

bitcoin,ethereum

Filter to specific coin slugs (CSV, up to 100 selectors combined). Must not be greater than 2000 characters.

symbols

string optional

BTC,ETH

Filter to specific coin symbols (CSV, case-insensitive, up to 100 selectors combined). Must not be greater than 1000 characters.

sort

string optional

-marketcap

Comma-separated sort fields; prefix with - for descending. Sortable: marketcap, rank, price, volume_24h, change_24h, change_7d. Must not be greater than 100 characters.

interval

string optional

24h

Movers window for /coins/gainers and /coins/losers only: 24h or 7d.

One of: 24h 7d

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/exchanges/binance-exchange/assets?page=1&per_page=50&type=coin&status=active&search=bitcoin&min_price=0.5&max_price=100000&min_marketcap=1000000&max_marketcap=5000000000000&min_volume=1000000&max_volume=100000000000&ids=38%2C39&slugs=bitcoin%2Cethereum&symbols=BTC%2CETH&sort=-marketcap&interval=24h" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/exchanges/binance-exchange/assets"
);

const params = {
    "page": "1",
    "per_page": "50",
    "type": "coin",
    "status": "active",
    "search": "bitcoin",
    "min_price": "0.5",
    "max_price": "100000",
    "min_marketcap": "1000000",
    "max_marketcap": "5000000000000",
    "min_volume": "1000000",
    "max_volume": "100000000000",
    "ids": "38,39",
    "slugs": "bitcoin,ethereum",
    "symbols": "BTC,ETH",
    "sort": "-marketcap",
    "interval": "24h",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/exchanges/binance-exchange/assets';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'type' => 'coin',
            'status' => 'active',
            'search' => 'bitcoin',
            'min_price' => '0.5',
            'max_price' => '100000',
            'min_marketcap' => '1000000',
            'max_marketcap' => '5000000000000',
            'min_volume' => '1000000',
            'max_volume' => '100000000000',
            'ids' => '38,39',
            'slugs' => 'bitcoin,ethereum',
            'symbols' => 'BTC,ETH',
            'sort' => '-marketcap',
            'interval' => '24h',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/exchanges/binance-exchange/assets'
params = {
  'page': '1',
  'per_page': '50',
  'type': 'coin',
  'status': 'active',
  'search': 'bitcoin',
  'min_price': '0.5',
  'max_price': '100000',
  'min_marketcap': '1000000',
  'max_marketcap': '5000000000000',
  'min_volume': '1000000',
  'max_volume': '100000000000',
  'ids': '38,39',
  'slugs': 'bitcoin,ethereum',
  'symbols': 'BTC,ETH',
  'sort': '-marketcap',
  'interval': '24h',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List wallets

Reviewed wallets with score, asset count, pros/cons counts, price model, status and release date. Paginated with Laravel's links + meta envelope, plus meta.top_score.

GET

http://localhost/api/v1/wallets

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

search

string optional

ledger

Free-text match on wallet name. Must not be greater than 100 characters.

min_score

integer optional

50

Only wallets with a review score at or above this value. Must be at least 0.

max_score

integer optional

214

Only wallets with a review score at or below this value. Must be at least 0.

tags

string optional

12,34

Filter by tag taxonomy: comma-separated category-group ids (the same ids the web facet filters submit). Must not be greater than 1000 characters.

ids

string optional

175,317

Filter to specific wallet ids (CSV, up to 100). Must not be greater than 1000 characters.

slugs

string optional

frostsnap,coin98-fusion-card

Filter to specific wallet slugs (CSV, up to 100). Must not be greater than 2000 characters.

sort

string optional

-score

Comma-separated sort fields; prefix with - for descending. Sortable: score, released_at, assets, pros, cons. Must not be greater than 100 characters.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/wallets?page=1&per_page=50&search=ledger&min_score=50&max_score=214&tags=12%2C34&ids=175%2C317&slugs=frostsnap%2Ccoin98-fusion-card&sort=-score" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/wallets"
);

const params = {
    "page": "1",
    "per_page": "50",
    "search": "ledger",
    "min_score": "50",
    "max_score": "214",
    "tags": "12,34",
    "ids": "175,317",
    "slugs": "frostsnap,coin98-fusion-card",
    "sort": "-score",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/wallets';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'search' => 'ledger',
            'min_score' => '50',
            'max_score' => '214',
            'tags' => '12,34',
            'ids' => '175,317',
            'slugs' => 'frostsnap,coin98-fusion-card',
            'sort' => '-score',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/wallets'
params = {
  'page': '1',
  'per_page': '50',
  'search': 'ledger',
  'min_score': '50',
  'max_score': '214',
  'tags': '12,34',
  'ids': '175,317',
  'slugs': 'frostsnap,coin98-fusion-card',
  'sort': '-score',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "id": 317,
5            "slug": "frostsnap",
6            "name": "Frostsnap",
7            "score": 125,
8            "assets": 1,
9            "pros": 18,
10            "cons": 0,
11            "price_model": "paid",
12            "status": "Active",
13            "released_at": null,
14            "logo": "https://bitculator.com/storage/media/logo/frostsnap.png"
15        }
16    ],
17    "links": {
18        "first": "https://bitculator.com/api/v1/wallets?page=1",
19        "last": "https://bitculator.com/api/v1/wallets?page=7",
20        "prev": null,
21        "next": "https://bitculator.com/api/v1/wallets?page=2"
22    },
23    "meta": {
24        "current_page": 1,
25        "from": 1,
26        "last_page": 7,
27        "per_page": 50,
28        "to": 50,
29        "total": 321,
30        "top_score": 214
31    }
32}

Wallet release timeline

The wallet list pinned to released_at descending (undated wallets last). Same row shape and pagination envelope as List wallets.

GET

http://localhost/api/v1/wallets/timeline

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

search

string optional

ledger

Free-text match on wallet name. Must not be greater than 100 characters.

min_score

integer optional

50

Only wallets with a review score at or above this value. Must be at least 0.

max_score

integer optional

214

Only wallets with a review score at or below this value. Must be at least 0.

tags

string optional

12,34

Filter by tag taxonomy: comma-separated category-group ids (the same ids the web facet filters submit). Must not be greater than 1000 characters.

ids

string optional

175,317

Filter to specific wallet ids (CSV, up to 100). Must not be greater than 1000 characters.

slugs

string optional

frostsnap,coin98-fusion-card

Filter to specific wallet slugs (CSV, up to 100). Must not be greater than 2000 characters.

sort

string optional

-score

Comma-separated sort fields; prefix with - for descending. Sortable: score, released_at, assets, pros, cons. Must not be greater than 100 characters.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/wallets/timeline?page=1&per_page=50&search=ledger&min_score=50&max_score=214&tags=12%2C34&ids=175%2C317&slugs=frostsnap%2Ccoin98-fusion-card&sort=-score" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/wallets/timeline"
);

const params = {
    "page": "1",
    "per_page": "50",
    "search": "ledger",
    "min_score": "50",
    "max_score": "214",
    "tags": "12,34",
    "ids": "175,317",
    "slugs": "frostsnap,coin98-fusion-card",
    "sort": "-score",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/wallets/timeline';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'search' => 'ledger',
            'min_score' => '50',
            'max_score' => '214',
            'tags' => '12,34',
            'ids' => '175,317',
            'slugs' => 'frostsnap,coin98-fusion-card',
            'sort' => '-score',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/wallets/timeline'
params = {
  'page': '1',
  'per_page': '50',
  'search': 'ledger',
  'min_score': '50',
  'max_score': '214',
  'tags': '12,34',
  'ids': '175,317',
  'slugs': 'frostsnap,coin98-fusion-card',
  'sort': '-score',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Compare wallets

Side-by-side comparison of 2–4 wallets with their full grouped tag taxonomy. data[] preserves the requested slug order so consumers can render columns positionally.

GET

http://localhost/api/v1/wallets/compare

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

slugs

string required

frostsnap,coin98-fusion-card

2–4 distinct wallet slugs, comma-separated.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/wallets/compare?slugs=frostsnap%2Ccoin98-fusion-card" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/wallets/compare"
);

const params = {
    "slugs": "frostsnap,coin98-fusion-card",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/wallets/compare';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'slugs' => 'frostsnap,coin98-fusion-card',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/wallets/compare'
params = {
  'slugs': 'frostsnap,coin98-fusion-card',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get wallet detail

Full single-wallet profile including the grouped tag taxonomy: categories is a list of {group, tags[]} where each tag has a slug, name and optional value. meta.top_score is the highest score across all wallets.

GET

http://localhost/api/v1/wallets/{slug}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

frostsnap

The wallet slug.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/wallets/frostsnap" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/wallets/frostsnap"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/wallets/frostsnap';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/wallets/frostsnap'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "data": {
3        "id": 317,
4        "slug": "frostsnap",
5        "name": "Frostsnap",
6        "score": 125,
7        "assets": 1,
8        "pros": 18,
9        "cons": 0,
10        "price_model": "paid",
11        "status": "Active",
12        "released_at": null,
13        "logo": "https://bitculator.com/storage/media/logo/frostsnap.png",
14        "website": "https://frostsnap.com",
15        "categories": [
16            {
17                "group": "type",
18                "tags": [
19                    {
20                        "slug": "hardware",
21                        "name": "Hardware",
22                        "value": null
23                    }
24                ]
25            },
26            {
27                "group": "storage",
28                "tags": [
29                    {
30                        "slug": "cold",
31                        "name": "Cold",
32                        "value": null
33                    }
34                ]
35            }
36        ]
37    },
38    "meta": {
39        "top_score": 214
40    }
41}

1{
2    "error": {
3        "code": "not_found",
4        "message": "Wallet not found."
5    }
6}

Wallet supported coins

Coins the wallet supports, returned in the same shape as List coins and accepting the same filters/sort.

GET

http://localhost/api/v1/wallets/{slug}/assets

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

frostsnap

The wallet slug.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

type

string optional

coin

Restrict to a single asset type: coin or token.

One of: coin token

status

string optional

active

Listing status: active, delisted, untracked, progressing, awaiting or preparing. Defaults to all public statuses.

One of: active delisted untracked progressing awaiting preparing

search

string optional

bitcoin

Free-text match on name or symbol. Must not be greater than 100 characters.

min_price

number optional

0.5

Only coins priced at or above this USD value. Must be at least 0.

max_price

number optional

100000

Only coins priced at or below this USD value. Must be at least 0.

min_marketcap

number optional

1000000

Only coins with a USD marketcap at or above this value. Must be at least 0.

max_marketcap

number optional

5000000000000

Only coins with a USD marketcap at or below this value. Must be at least 0.

min_volume

number optional

1000000

Only coins with 24h USD volume at or above this value. Must be at least 0.

max_volume

number optional

100000000000

Only coins with 24h USD volume at or below this value. Must be at least 0.

ids

string optional

38,39

Filter to specific coin ids (CSV, up to 100 selectors combined with slugs/symbols). Must not be greater than 1000 characters.

slugs

string optional

bitcoin,ethereum

Filter to specific coin slugs (CSV, up to 100 selectors combined). Must not be greater than 2000 characters.

symbols

string optional

BTC,ETH

Filter to specific coin symbols (CSV, case-insensitive, up to 100 selectors combined). Must not be greater than 1000 characters.

sort

string optional

-marketcap

Comma-separated sort fields; prefix with - for descending. Sortable: marketcap, rank, price, volume_24h, change_24h, change_7d. Must not be greater than 100 characters.

interval

string optional

24h

Movers window for /coins/gainers and /coins/losers only: 24h or 7d.

One of: 24h 7d

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/wallets/frostsnap/assets?page=1&per_page=50&type=coin&status=active&search=bitcoin&min_price=0.5&max_price=100000&min_marketcap=1000000&max_marketcap=5000000000000&min_volume=1000000&max_volume=100000000000&ids=38%2C39&slugs=bitcoin%2Cethereum&symbols=BTC%2CETH&sort=-marketcap&interval=24h" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/wallets/frostsnap/assets"
);

const params = {
    "page": "1",
    "per_page": "50",
    "type": "coin",
    "status": "active",
    "search": "bitcoin",
    "min_price": "0.5",
    "max_price": "100000",
    "min_marketcap": "1000000",
    "max_marketcap": "5000000000000",
    "min_volume": "1000000",
    "max_volume": "100000000000",
    "ids": "38,39",
    "slugs": "bitcoin,ethereum",
    "symbols": "BTC,ETH",
    "sort": "-marketcap",
    "interval": "24h",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/wallets/frostsnap/assets';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'type' => 'coin',
            'status' => 'active',
            'search' => 'bitcoin',
            'min_price' => '0.5',
            'max_price' => '100000',
            'min_marketcap' => '1000000',
            'max_marketcap' => '5000000000000',
            'min_volume' => '1000000',
            'max_volume' => '100000000000',
            'ids' => '38,39',
            'slugs' => 'bitcoin,ethereum',
            'symbols' => 'BTC,ETH',
            'sort' => '-marketcap',
            'interval' => '24h',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/wallets/frostsnap/assets'
params = {
  'page': '1',
  'per_page': '50',
  'type': 'coin',
  'status': 'active',
  'search': 'bitcoin',
  'min_price': '0.5',
  'max_price': '100000',
  'min_marketcap': '1000000',
  'max_marketcap': '5000000000000',
  'min_volume': '1000000',
  'max_volume': '100000000000',
  'ids': '38,39',
  'slugs': 'bitcoin,ethereum',
  'symbols': 'BTC,ETH',
  'sort': '-marketcap',
  'interval': '24h',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Global market snapshot

One-shot market overview: total marketcap and 24h volume, counts of cryptocurrencies / tokens / exchanges / pairs / markets, dominance (BTC & ETH share plus the rank-based top3), and the market fear_greed reading.

GET

http://localhost/api/v1/global

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/global" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/global"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/global';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/global'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "data": {
3        "total_marketcap": 2037527560616,
4        "total_volume_24h": 83977305058,
5        "total_cryptocurrencies": 134,
6        "total_tokens": 50,
7        "total_exchanges": 10,
8        "total_pairs": 823,
9        "total_markets": 4172,
10        "dominance": {
11            "btc": 62.07,
12            "eth": 9.97,
13            "top3": [
14                {
15                    "symbol": "BTC",
16                    "domination": 62.07
17                },
18                {
19                    "symbol": "ETH",
20                    "domination": 9.97
21                },
22                {
23                    "symbol": "USDT",
24                    "domination": 8.17
25                }
26            ]
27        },
28        "fear_greed": {
29            "score": 15,
30            "regime": "neutral"
31        },
32        "last_updated": "2026-07-03T10:16:06+00:00"
33    }
34}

Market heatmap

Top-100 treemap rows plus framing stats (total marketcap/volume, dominance and the market Fear & Greed score) — the API twin of the web heatmap.

GET

http://localhost/api/v1/global/heatmap

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/global/heatmap" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/global/heatmap"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/global/heatmap';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/global/heatmap'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "data": [
3        {
4            "slug": "bitcoin",
5            "name": "Bitcoin",
6            "symbol": "BTC",
7            "price": "109731.2",
8            "marketcap": 2183456789012,
9            "change_24h": 1.24,
10            "change_7d": -2.31,
11            "logo": "https://bitculator.com/storage/media/assets/bitcoin-small.png"
12        }
13    ],
14    "meta": {
15        "total_marketcap": 3456789012345,
16        "total_volume_24h": 98765432109,
17        "dominance": {
18            "btc": 63.2,
19            "eth": 9.1,
20            "top3": 74.6
21        },
22        "fear_greed": 15
23    }
24}

Global marketcap / volume history

Total-market time series for marketcap or volume. Granularity follows the period: 24h = half-hourly, 7d = hourly, 30d/all = daily (finer rollups are pruned).

GET

http://localhost/api/v1/global/history/{metric}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

metric

string required

marketcap

Which series: marketcap or volume.

Query parameters

period

string optional

7d

24h, 7d, 30d or all (default 24h).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/global/history/marketcap?period=7d" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/global/history/marketcap"
);

const params = {
    "period": "7d",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/global/history/marketcap';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'period' => '7d',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/global/history/marketcap'
params = {
  'period': '7d',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Community vote tallies

The coin's bullish/bearish community tallies over the rolling 24h window.

GET

http://localhost/api/v1/coins/{slug}/votes

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin's slug identifier.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/bitcoin/votes" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin/votes"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin/votes';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin/votes'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "data": {
3        "coin": "bitcoin",
4        "bullish": 184,
5        "bearish": 42,
6        "total": 226
7    }
8}

Cast a sentiment vote

Casts the key owner's sentiment vote for a coin. One vote per key owner per coin per rolling 24h window — re-voting inside the window updates the existing vote.

POST

http://localhost/api/v1/coins/{slug}/votes

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin's slug identifier.

Body parameters

vote

string required

bullish

Your sentiment: bullish or bearish.

Request

curl --request POST \
    "http://localhost/api/v1/coins/bitcoin/votes" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"vote\": \"bullish\"
}"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin/votes"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "vote": "bullish"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin/votes';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'vote' => 'bullish',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin/votes'
payload = {
    "vote": "bullish"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Response

1{
2    "data": {
3        "coin": "bitcoin",
4        "bullish": 185,
5        "bearish": 42,
6        "total": 227,
7        "your_vote": "bullish"
8    }
9}

Fear & Greed index

The current Fear & Greed reading (a 15-minute snapshot — no history). Omit coin for the market-wide index, or pass a coin slug for a per-coin reading. intervals carries the 7d/30d sub-scores and their component breakdown.

GET

http://localhost/api/v1/sentiment/fear-greed

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

coin

string optional

bitcoin

Coin slug for a per-coin reading; omit for the market index.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/sentiment/fear-greed?coin=bitcoin" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/sentiment/fear-greed"
);

const params = {
    "coin": "bitcoin",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/sentiment/fear-greed';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'coin' => 'bitcoin',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/sentiment/fear-greed'
params = {
  'coin': 'bitcoin',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": {
3        "scope": "market",
4        "score": 15,
5        "regime": "neutral",
6        "intervals": {
7            "7d": {
8                "score": 15,
9                "regime": "neutral",
10                "breakdown": {
11                    "volume": 40,
12                    "breadth": 1,
13                    "momentum": -8,
14                    "volatility": 36
15                },
16                "score_normalized": 15
17            },
18            "30d": {
19                "score": 18,
20                "regime": "neutral",
21                "breakdown": {
22                    "volume": 80,
23                    "breadth": 1,
24                    "momentum": -10,
25                    "volatility": 18
26                },
27                "score_normalized": 18
28            }
29        }
30    }
31}

1{
2    "error": {
3        "code": "not_found",
4        "message": "No fear & greed data for this scope."
5    }
6}

Bull / Bear index

The current Bull/Bear reading (a 15-minute snapshot — no history). Omit coin for the market-wide index, or pass a coin slug for a per-coin reading.

GET

http://localhost/api/v1/sentiment/bull-bear

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

coin

string optional

bitcoin

Coin slug for a per-coin reading; omit for the market index.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/sentiment/bull-bear?coin=bitcoin" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/sentiment/bull-bear"
);

const params = {
    "coin": "bitcoin",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/sentiment/bull-bear';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'coin' => 'bitcoin',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/sentiment/bull-bear'
params = {
  'coin': 'bitcoin',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Altseason index

The current altseason reading (count of coins beating BTC out of the top 100), with optional daily history. Unlike Fear & Greed, altseason has full daily history — pass days to include it.

GET

http://localhost/api/v1/sentiment/altseason

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

days

integer optional

30

Days of daily history to include (1–365; 0/omit = current only).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/sentiment/altseason?days=30" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/sentiment/altseason"
);

const params = {
    "days": "30",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/sentiment/altseason';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'days' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/sentiment/altseason'
params = {
  'days': '30',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Market indicator tally

The market-wide technical tally — 25 indicator categories rolled up, each with its current state, score and category data.

GET

http://localhost/api/v1/sentiment/indicators

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/sentiment/indicators" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/sentiment/indicators"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/sentiment/indicators';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/sentiment/indicators'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Indicator snapshot

The multi-indicator snapshot — every indicator category's latest state (bullish/bearish/sheepish…), score and raw data, in one payload.

GET

http://localhost/api/v1/coins/{slug}/indicators

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin slug.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/bitcoin/indicators" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin/indicators"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin/indicators';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin/indicators'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "data": [
3        {
4            "indicator": "OBV",
5            "state": "bearish",
6            "score": -1,
7            "data": {
8                "value": 1755907904411,
9                "window": 21
10            }
11        },
12        {
13            "indicator": "macd",
14            "state": "bullish",
15            "score": 1,
16            "data": {
17                "value": -2811.87686067,
18                "signal": -3364.35539147,
19                "histogram": 552.4785308
20            }
21        }
22    ],
23    "meta": {
24        "coin": "bitcoin"
25    }
26}

1{
2    "error": {
3        "code": "not_found",
4        "message": "No indicator data for this coin yet."
5    }
6}

Indicator family series

One indicator family's daily time series. Families with multiple windows accept a period, and the valid windows differ per family: RSI/Stoch-RSI 7/14/21/28, SMA 50/100/200, CCI 20/50/100, MFI 7/14/28, Williams %R 14/20/50, price/volume-volatility 7/14/30. Single-series families (MACD, OBV, ADX, VWAP, CMF) ignore period. Young coins return leading warm-up nulls.

Some long windows require a paid plan: RSI & Stoch-RSI 21/28-day and the 30-day volatility windows need Starter or higher — requesting them on the Free plan returns 403 with code plan_required.

GET

http://localhost/api/v1/coins/{slug}/indicators/{family}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin slug.

family

string required

rsi

Indicator family — one of rsi, stoch-rsi, sma, cci, mfi, williams-r, price-volatility, volume-volatility, macd, obv, adx, vwap, cmf.

Query parameters

period

integer optional

14

Window length (only where the family has windows; must be one of that family's valid windows).

start

string optional

2026-06-01

ISO date lower bound.

end

string optional

2026-06-30

ISO date upper bound.

limit

integer optional

30

Max rows (1–1000, default 365).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/bitcoin/indicators/rsi?period=14&start=2026-06-01&end=2026-06-30&limit=30" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin/indicators/rsi"
);

const params = {
    "period": "14",
    "start": "2026-06-01",
    "end": "2026-06-30",
    "limit": "30",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin/indicators/rsi';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'period' => '14',
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin/indicators/rsi'
params = {
  'period': '14',
  'start': '2026-06-01',
  'end': '2026-06-30',
  'limit': '30',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "date": "2026-06-14",
5            "value": 42
6        },
7        {
8            "date": "2026-06-15",
9            "value": 46
10        }
11    ],
12    "meta": {
13        "coin": "bitcoin",
14        "indicator": "rsi",
15        "period": 14,
16        "count": 2
17    }
18}

1{
2    "error": {
3        "code": "plan_required",
4        "message": "The 28-day rsi window requires the Starter plan or higher.",
5        "details": {
6            "required_plan": "starter"
7        }
8    }
9}

1{
2    "error": {
3        "code": "not_found",
4        "message": "Unknown indicator. Families: rsi, stoch-rsi, sma, cci, mfi, williams-r, price-volatility, volume-volatility, macd, obv, adx, vwap, cmf."
5    }
6}

Liquidation feed

The raw liquidation feed (~last 48h, then pruned), newest first. Source coverage is currently OKX swap markets. Prices are decimal strings. meta carries the pagination fields plus a retention and note.

GET

http://localhost/api/v1/liquidations

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based). Must be at least 1.

per_page

integer optional

50

Rows per page. The cap is plan-based (Free 100, Starter/Pro 250); exceeding it returns 422 rather than clamping. Must be at least 1. Must not be greater than 100.

exchange

string optional

okx

Restrict to a single exchange by slug. Source coverage is currently OKX swap markets. Must match the regex /^[a-z0-9-]{1,120}$/.

instrument

string optional

swap

Instrument type: future, option, swap, spot or margin.

One of: future option swap spot margin

position

string optional

short

Liquidated position side: long or short.

One of: long short

order

string optional

buy

Fill side that triggered the liquidation: buy or sell.

One of: buy sell

symbol

string optional

BTC

Prefix match on the venue instId (e.g. BTC matches BTC-USDT-SWAP). Must match the regex /^[A-Za-z0-9$.-]{1,25}$/.

min_usd

number optional

1000

Only liquidations with a USD value at or above this threshold. Must be at least 0.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/liquidations?page=1&per_page=50&exchange=okx&instrument=swap&position=short&order=buy&symbol=BTC&min_usd=1000" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/liquidations"
);

const params = {
    "page": "1",
    "per_page": "50",
    "exchange": "okx",
    "instrument": "swap",
    "position": "short",
    "order": "buy",
    "symbol": "BTC",
    "min_usd": "1000",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/liquidations';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '50',
            'exchange' => 'okx',
            'instrument' => 'swap',
            'position' => 'short',
            'order' => 'buy',
            'symbol' => 'BTC',
            'min_usd' => '1000',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/liquidations'
params = {
  'page': '1',
  'per_page': '50',
  'exchange': 'okx',
  'instrument': 'swap',
  'position': 'short',
  'order': 'buy',
  'symbol': 'BTC',
  'min_usd': '1000',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "symbol": "NEAR-USDT-SWAP",
5            "exchange": {
6                "id": 20,
7                "slug": "okx",
8                "name": "OKX"
9            },
10            "instrument": "swap",
11            "position": "short",
12            "order": "buy",
13            "price": "2.245",
14            "value_usd": 5727.73,
15            "quantity": 259.1,
16            "liquidated_at": "2026-06-21T07:39:41+00:00"
17        }
18    ],
19    "meta": {
20        "current_page": 1,
21        "per_page": 50,
22        "total": 4681,
23        "last_page": 94,
24        "retention": "~48 hours (raw feed is pruned)",
25        "note": "Source coverage: OKX swap markets."
26    }
27}

Hourly liquidations

Hourly long/short USD totals over the raw feed. Because the raw feed is pruned at ~48h, hours is capped at 48. Source coverage is currently OKX swap markets.

GET

http://localhost/api/v1/liquidations/hourly

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

hours

integer optional

24

Look-back window in hours (1–48, default 24).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/liquidations/hourly?hours=24" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/liquidations/hourly"
);

const params = {
    "hours": "24",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/liquidations/hourly';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'hours' => '24',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/liquidations/hourly'
params = {
  'hours': '24',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "hour": "2026-07-03T08:00:00+00:00",
5            "liquidations": 112,
6            "total_usd": 1834567.21,
7            "long_usd": 1034567.11,
8            "short_usd": 800000.1
9        }
10    ],
11    "meta": {
12        "hours": 24,
13        "note": "Source coverage: OKX swap markets."
14    }
15}

Daily liquidations

Daily aggregates (kept forever), summed across exchanges/instruments per day — total/long/short USD plus long/short position counts. Today's row is partial and updates every ~15 minutes. Source coverage is currently OKX swap markets.

GET

http://localhost/api/v1/liquidations/daily

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

days

integer optional

30

Number of calendar days incl. today (1–365, default 30).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/liquidations/daily?days=30" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/liquidations/daily"
);

const params = {
    "days": "30",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/liquidations/daily';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'days' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/liquidations/daily'
params = {
  'days': '30',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "date": "2026-07-02",
5            "total_usd": 27888888.76,
6            "long_usd": 18345672.1,
7            "short_usd": 9543216.66,
8            "longs": 4231,
9            "shorts": 2614
10        }
11    ],
12    "meta": {
13        "days": 30,
14        "note": "Source coverage: OKX swap markets."
15    }
16}

Today's liquidation summary

Today so far — total/long/short USD, position counts and long-vs-short dominance. Figures are partial and update every ~15 minutes; data is null until the first liquidation of the day is recorded. Source coverage is currently OKX swap markets.

GET

http://localhost/api/v1/liquidations/summary

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/liquidations/summary" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/liquidations/summary"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/liquidations/summary';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/liquidations/summary'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "data": {
3        "date": "2026-07-03",
4        "total_usd": 12345678.9,
5        "long_usd": 8345678.9,
6        "short_usd": 4000000,
7        "longs": 1834,
8        "shorts": 961,
9        "dominance": {
10            "long": 67.6,
11            "short": 32.4
12        }
13    },
14    "meta": {
15        "note": "Source coverage: OKX swap markets. Today's figures are partial and update every ~15 minutes."
16    }
17}

Liquidation netflow

Long-vs-short liquidation USD flow per day over the window. Source coverage is currently OKX swap markets.

GET

http://localhost/api/v1/liquidations/netflow

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

days

integer optional

30

Number of calendar days incl. today (1–90, default 30).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/liquidations/netflow?days=30" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/liquidations/netflow"
);

const params = {
    "days": "30",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/liquidations/netflow';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'days' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/liquidations/netflow'
params = {
  'days': '30',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "date": "2026-07-02",
5            "long": 1834567.21,
6            "short": 954321.55,
7            "total": 2788888.76,
8            "longs": 420,
9            "shorts": 261
10        }
11    ],
12    "meta": {
13        "days": 30,
14        "note": "Source coverage: OKX swap markets."
15    }
16}

Top liquidated coins

Top coins by liquidation volume over the recent window, with the long/short USD split per coin. Source coverage is currently OKX swap markets.

GET

http://localhost/api/v1/liquidations/coins

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

hours

integer optional

24

Look-back window in hours (1–48, default 24).

limit

integer optional

8

Number of coins to return (1–20, default 8).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/liquidations/coins?hours=24&limit=8" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/liquidations/coins"
);

const params = {
    "hours": "24",
    "limit": "8",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/liquidations/coins';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'hours' => '24',
            'limit' => '8',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/liquidations/coins'
params = {
  'hours': '24',
  'limit': '8',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "symbol": "BTC",
5            "name": "Bitcoin",
6            "slug": "bitcoin",
7            "logo": "https://bitculator.com/storage/media/assets/bitcoin-small.png",
8            "long": 734567.21,
9            "short": 954321.55,
10            "total": 1688888.76
11        }
12    ],
13    "meta": {
14        "hours": 24,
15        "note": "Source coverage: OKX swap markets."
16    }
17}

Convert between assets

Server-side conversion between any two active assets (crypto AND fiat). to accepts a CSV for multi-target conversion; reversing is just swapping from/to. Conversion is linear, so value = unit_rate * amount. Fiat FX rates refresh ~twice daily; crypto rates ~every minute.

GET

http://localhost/api/v1/convert

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

from

string required

bitcoin

Source asset slug.

to

string required

ethereum

Target asset slug(s), comma-separated (up to 10).

amount

number optional

2.5

Amount of the source asset to convert (default 1).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/convert?from=bitcoin&to=ethereum&amount=2.5" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/convert"
);

const params = {
    "from": "bitcoin",
    "to": "ethereum",
    "amount": "2.5",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/convert';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'from' => 'bitcoin',
            'to' => 'ethereum',
            'amount' => '2.5',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/convert'
params = {
  'from': 'bitcoin',
  'to': 'ethereum',
  'amount': '2.5',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": {
3        "from": {
4            "slug": "bitcoin",
5            "symbol": "BTC"
6        },
7        "amount": 1,
8        "results": [
9            {
10                "slug": "ethereum",
11                "symbol": "ETH",
12                "value": "37.980395960595"
13            }
14        ]
15    }
16}

1{
2    "error": {
3        "code": "not_found",
4        "message": "Unknown currency: dogecoinx."
5    }
6}

List fiat currencies

The active fiat currencies with their USD FX rates: rate_per_usd (units per USD) and its inverse usd_value. Fiat FX rates refresh ~twice daily.

GET

http://localhost/api/v1/fiats

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/fiats" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/fiats"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/fiats';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/fiats'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List conversion rates

The vs-currencies usable as conversion legs — the top fiats, coins and tokens — each with a normalized usd_value (USD per one unit). Coin/token values refresh ~every minute; the slow fiat rates are cached separately (~twice daily).

GET

http://localhost/api/v1/rates

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/rates" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/rates"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/rates';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/rates'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

DCA calculator

Dollar-cost averaging backtest over the coin's real daily price history: one buy of amount per interval between start and end. Pass series=true to include the full per-purchase series.

GET

http://localhost/api/v1/calculators/dca

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

slug

string required

bitcoin

The coin's slug identifier.

amount

number required

100

USD spent per purchase (0.01–1,000,000,000).

interval

string required

weekly

Purchase cadence: daily, weekly, monthly, quarterly or yearly.

start

string required

2024-01-01

date First purchase date (after 2008-12-31).

end

string optional

2025-01-01

date Last purchase date (defaults to today).

series

boolean optional

false

Include the per-purchase series in the payload.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/calculators/dca?slug=bitcoin&amount=100&interval=weekly&start=2024-01-01&end=2025-01-01&series=" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/calculators/dca"
);

const params = {
    "slug": "bitcoin",
    "amount": "100",
    "interval": "weekly",
    "start": "2024-01-01",
    "end": "2025-01-01",
    "series": "0",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/calculators/dca';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'slug' => 'bitcoin',
            'amount' => '100',
            'interval' => 'weekly',
            'start' => '2024-01-01',
            'end' => '2025-01-01',
            'series' => '0',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/calculators/dca'
params = {
  'slug': 'bitcoin',
  'amount': '100',
  'interval': 'weekly',
  'start': '2024-01-01',
  'end': '2025-01-01',
  'series': '0',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": {
3        "summary": {
4            "purchases": 53,
5            "invested": 5300,
6            "accumulated": 0.0754210998,
7            "final_value": 7098.9,
8            "profit": 1798.9,
9            "roi": 33.94
10        },
11        "series": null
12    },
13    "meta": {
14        "coin": "bitcoin",
15        "interval": "weekly",
16        "start": "2024-01-01",
17        "end": "2025-01-01",
18        "amount_per_buy": 100,
19        "currency": "USD"
20    }
21}

Profit / loss calculator

What a buy-then-sell between two historical dates returned, using the coin's real prices on those dates. Fees are flat USD amounts, not percentages.

GET

http://localhost/api/v1/calculators/profit-loss

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

slug

string required

bitcoin

The coin's slug identifier.

amount

number required

1000

USD invested at buy_date (0.01–1,000,000,000).

buy_date

string required

2023-01-01

date Purchase date.

sell_date

string required

2025-01-01

date Sale date (on/after buy_date).

buy_fee

number optional

10

Flat purchase fee in USD (default 0).

sell_fee

number optional

10

Flat sale fee in USD (default 0).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/calculators/profit-loss?slug=bitcoin&amount=1000&buy_date=2023-01-01&sell_date=2025-01-01&buy_fee=10&sell_fee=10" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/calculators/profit-loss"
);

const params = {
    "slug": "bitcoin",
    "amount": "1000",
    "buy_date": "2023-01-01",
    "sell_date": "2025-01-01",
    "buy_fee": "10",
    "sell_fee": "10",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/calculators/profit-loss';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'slug' => 'bitcoin',
            'amount' => '1000',
            'buy_date' => '2023-01-01',
            'sell_date' => '2025-01-01',
            'buy_fee' => '10',
            'sell_fee' => '10',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/calculators/profit-loss'
params = {
  'slug': 'bitcoin',
  'amount': '1000',
  'buy_date': '2023-01-01',
  'sell_date': '2025-01-01',
  'buy_fee': '10',
  'sell_fee': '10',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": {
3        "buy_price": "16625.08",
4        "sell_price": "93429.2",
5        "quantity": 0.0595486254,
6        "investment_worth": 5563.58,
7        "total_fees": 20,
8        "profit": 4553.58,
9        "roi": 455.36
10    },
11    "meta": {
12        "coin": "bitcoin",
13        "amount": 1000,
14        "buy_date": "2023-01-01",
15        "sell_date": "2025-01-01",
16        "buy_fee": 10,
17        "sell_fee": 10,
18        "currency": "USD"
19    }
20}

Compound interest calculator

Pure math — no market data. Note that the rate applies PER COMPOUNDING PERIOD (the web calculator's convention), not per year.

GET

http://localhost/api/v1/calculators/compound-interest

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

principal

number required

10000

Starting balance in USD.

rate

number required

1

Interest rate in % per compounding period.

duration

integer required

5

Length of the projection (years are capped at 50).

duration_unit

string optional

years

years (default) or months.

compound_frequency

string optional

monthly

daily, weekly, monthly (default), quarterly or annually.

contribution

number optional

100

Recurring deposit in USD (default 0).

contribution_frequency

string optional

monthly

daily, weekly, monthly (default), quarterly or annually.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/calculators/compound-interest?principal=10000&rate=1&duration=5&duration_unit=years&compound_frequency=monthly&contribution=100&contribution_frequency=monthly" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/calculators/compound-interest"
);

const params = {
    "principal": "10000",
    "rate": "1",
    "duration": "5",
    "duration_unit": "years",
    "compound_frequency": "monthly",
    "contribution": "100",
    "contribution_frequency": "monthly",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/calculators/compound-interest';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'principal' => '10000',
            'rate' => '1',
            'duration' => '5',
            'duration_unit' => 'years',
            'compound_frequency' => 'monthly',
            'contribution' => '100',
            'contribution_frequency' => 'monthly',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/calculators/compound-interest'
params = {
  'principal': '10000',
  'rate': '1',
  'duration': '5',
  'duration_unit': 'years',
  'compound_frequency': 'monthly',
  'contribution': '100',
  'contribution_frequency': 'monthly',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": {
3        "final_balance": 24471.19,
4        "total_contributions": 16000,
5        "total_interest": 8471.19,
6        "roi": 52.94
7    },
8    "meta": {
9        "note": "The rate applies per compounding period (web calculator parity), not per year."
10    }
11}

Loan vs sell calculator

Borrow against crypto vs sell it — compares both scenarios using the coin's CURRENT price. Informational projection, not financial advice.

GET

http://localhost/api/v1/calculators/loan

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

slug

string required

bitcoin

The coin's slug identifier.

crypto_amount

number required

2

How much of the coin you hold.

needed_cash

number required

50000

USD you need to free up.

term_months

integer optional

36

Loan term in months (default 36).

interest_rate

number optional

10

Loan APR in % (default 10).

ltv

number optional

50

Loan-to-value ratio in % (default 50).

expected_growth

number optional

25

Expected coin price growth over the term in % (default 25).

tax_rate

number optional

25

Capital-gains tax in % applied to the sale (default 25).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/calculators/loan?slug=bitcoin&crypto_amount=2&needed_cash=50000&term_months=36&interest_rate=10&ltv=50&expected_growth=25&tax_rate=25" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/calculators/loan"
);

const params = {
    "slug": "bitcoin",
    "crypto_amount": "2",
    "needed_cash": "50000",
    "term_months": "36",
    "interest_rate": "10",
    "ltv": "50",
    "expected_growth": "25",
    "tax_rate": "25",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/calculators/loan';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'slug' => 'bitcoin',
            'crypto_amount' => '2',
            'needed_cash' => '50000',
            'term_months' => '36',
            'interest_rate' => '10',
            'ltv' => '50',
            'expected_growth' => '25',
            'tax_rate' => '25',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/calculators/loan'
params = {
  'slug': 'bitcoin',
  'crypto_amount': '2',
  'needed_cash': '50000',
  'term_months': '36',
  'interest_rate': '10',
  'ltv': '50',
  'expected_growth': '25',
  'tax_rate': '25',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": {
3        "current_price": "109731.2",
4        "collateral_value": 219462.4,
5        "max_loan": 109731.2,
6        "loan_possible": true,
7        "loan_scenario": {
8            "monthly_payment": 1613.4,
9            "total_payback": 58082.4,
10            "total_interest": 8082.4,
11            "net_value": 216296.72
12        },
13        "sell_scenario": {
14            "crypto_sold": 0.4556647344,
15            "capital_gains_tax": 12500,
16            "net_value": 230378.86
17        },
18        "better_scenario": "sell",
19        "opportunity_cost": 14082.14,
20        "break_even_growth": 31.42,
21        "risk_level": "medium"
22    },
23    "meta": {
24        "coin": "bitcoin",
25        "currency": "USD",
26        "note": "Informational projection — the tax model taxes the full proceeds (no cost basis), matching the web calculator."
27    }
28}

Staking rewards calculator

Pure math — staking rewards with optional compounding and a validator commission. No market data is read.

GET

http://localhost/api/v1/calculators/staking

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

amount

number required

1000

Amount staked, in the staked asset's units.

period

number required

2

Length of the staking period (capped at the 50-year equivalent).

period_unit

string optional

years

years (default), months or days.

apy

number required

5

Advertised APY in %.

compound_frequency

string optional

monthly

never, daily, weekly, monthly (default) or yearly.

commission

number optional

10

Validator commission in %, taken from rewards (default 0).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/calculators/staking?amount=1000&period=2&period_unit=years&apy=5&compound_frequency=monthly&commission=10" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/calculators/staking"
);

const params = {
    "amount": "1000",
    "period": "2",
    "period_unit": "years",
    "apy": "5",
    "compound_frequency": "monthly",
    "commission": "10",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/calculators/staking';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'amount' => '1000',
            'period' => '2',
            'period_unit' => 'years',
            'apy' => '5',
            'compound_frequency' => 'monthly',
            'commission' => '10',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/calculators/staking'
params = {
  'amount': '1000',
  'period': '2',
  'period_unit': 'years',
  'apy': '5',
  'compound_frequency': 'monthly',
  'commission': '10',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": {
3        "final_balance": 1094.42,
4        "total_rewards": 94.42,
5        "yearly_reward": 47.21,
6        "monthly_reward": 3.93,
7        "roi": 9.44,
8        "risk_level": "low"
9    }
10}

Coin videos

Curated videos attached to a coin (the coin page's Videos tab), paginated.

GET

http://localhost/api/v1/coins/{slug}/videos

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin's slug identifier.

Query parameters

page

integer optional

1

Page number (1-based).

per_page

integer optional

10

Rows per page (1–50, default 10).

type

string optional

review

Filter by video type (e.g. overview, tutorial, explainer, review, analysis, news).

search

string optional

halving

Free-text match on the title.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/bitcoin/videos?page=1&per_page=10&type=review&search=halving" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin/videos"
);

const params = {
    "page": "1",
    "per_page": "10",
    "type": "review",
    "search": "halving",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin/videos';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '10',
            'type' => 'review',
            'search' => 'halving',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin/videos'
params = {
  'page': '1',
  'per_page': '10',
  'type': 'review',
  'search': 'halving',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Coin insight timeline

The coin's insight timeline — the same payload the asset page's insights panel uses, windowed by offset/limit.

GET

http://localhost/api/v1/coins/{slug}/insights

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

bitcoin

The coin's slug identifier.

Query parameters

locale

string optional

en

Content language (falls back to English).

offset

integer optional

0

Rows to skip (0–500, default 0).

limit

integer optional

5

Rows to return (1–50, default 5).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/coins/bitcoin/insights?locale=en&offset=0&limit=5" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/coins/bitcoin/insights"
);

const params = {
    "locale": "en",
    "offset": "0",
    "limit": "5",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/coins/bitcoin/insights';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'locale' => 'en',
            'offset' => '0',
            'limit' => '5',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/coins/bitcoin/insights'
params = {
  'locale': 'en',
  'offset': '0',
  'limit': '5',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List articles

Published articles, newest first, paginated. Filter by tag or by a related coin / exchange / wallet slug, or free-text search. Each row is a summary (title, subtitle, tags, reading time, hero image, related entities, dates).

GET

http://localhost/api/v1/articles

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based).

per_page

integer optional

20

Rows per page (1–50, default 20).

locale

string optional

en

Content language (falls back to English).

tag

string optional

guide

Filter by tag: news, guide, tutorial, explainer, analysis, review, trading, overview or information.

coin

string optional

bitcoin

Filter to articles related to this coin slug.

exchange

string optional

binance-exchange

Filter to articles related to this exchange slug.

wallet

string optional

frostsnap

Filter to articles related to this wallet slug.

search

string optional

halving

Free-text match on heading/subheading.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/articles?page=1&per_page=20&locale=en&tag=guide&coin=bitcoin&exchange=binance-exchange&wallet=frostsnap&search=halving" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/articles"
);

const params = {
    "page": "1",
    "per_page": "20",
    "locale": "en",
    "tag": "guide",
    "coin": "bitcoin",
    "exchange": "binance-exchange",
    "wallet": "frostsnap",
    "search": "halving",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/articles';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '20',
            'locale' => 'en',
            'tag' => 'guide',
            'coin' => 'bitcoin',
            'exchange' => 'binance-exchange',
            'wallet' => 'frostsnap',
            'search' => 'halving',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/articles'
params = {
  'page': '1',
  'per_page': '20',
  'locale': 'en',
  'tag': 'guide',
  'coin': 'bitcoin',
  'exchange': 'binance-exchange',
  'wallet': 'frostsnap',
  'search': 'halving',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "id": 14,
5            "slug": "what-is-bitcoin",
6            "title": "What Is Bitcoin?",
7            "subtitle": "A plain-language introduction to the first cryptocurrency.",
8            "locale": "en",
9            "tags": [
10                "guide",
11                "analysis"
12            ],
13            "reading_time_minutes": 7,
14            "hero_image": "https://bitculator.com/storage/media/articles/what-is-bitcoin.png",
15            "entities": [],
16            "published_at": "2026-06-21",
17            "updated_at": "2026-06-21"
18        }
19    ],
20    "meta": {
21        "current_page": 1,
22        "per_page": 20,
23        "total": 10,
24        "last_page": 1
25    }
26}

Get an article

One published article with its full body, tags, hero image, helpful counters and related entities. locale picks the content language with per-field English fallback (the payload reports which locale actually won).

GET

http://localhost/api/v1/articles/{slug}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

what-is-bitcoin

The article's slug.

Query parameters

locale

string optional

en

Content language (falls back to English).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/articles/what-is-bitcoin?locale=en" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/articles/what-is-bitcoin"
);

const params = {
    "locale": "en",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/articles/what-is-bitcoin';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'locale' => 'en',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/articles/what-is-bitcoin'
params = {
  'locale': 'en',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Submit article feedback

Registers a thumbs-up/down on an article — the same counters the web's helpful buttons use. Per-key throttling applies upstream.

POST

http://localhost/api/v1/articles/{slug}/feedback

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

slug

string required

what-is-bitcoin

The article's slug.

Body parameters

helpful

boolean required

true

true for helpful, false for not helpful.

Request

curl --request POST \
    "http://localhost/api/v1/articles/what-is-bitcoin/feedback" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"helpful\": true
}"

const url = new URL(
    "http://localhost/api/v1/articles/what-is-bitcoin/feedback"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "helpful": true
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/articles/what-is-bitcoin/feedback';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'helpful' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/articles/what-is-bitcoin/feedback'
payload = {
    "helpful": true
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Response

1{
2    "data": {
3        "article": "what-is-bitcoin",
4        "helpful_yes": 13,
5        "helpful_no": 2
6    }
7}

Get a video

One curated video with its YouTube id, title, type, duration and the coins/exchanges/wallets it is attached to.

GET

http://localhost/api/v1/videos/{id}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

id

integer required

87

The video id.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/videos/87" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/videos/87"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/videos/87';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/videos/87'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

List insights

AI-generated market insights, paginated. Filter by type, a related coin slug or free-text search; locale picks the headline/summary language with English fallback.

GET

http://localhost/api/v1/insights

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based).

per_page

integer optional

20

Rows per page (1–50, default 20).

locale

string optional

en

Content language (falls back to English).

type

string optional

per_asset

Filter by insight type: per_asset, market_overview or narrative.

coin

string optional

bitcoin

Filter to insights about this coin slug.

search

string optional

etf

Free-text match on the headline.

sort

string optional

first_reported

Sort order: first_reported (default) or last_updated.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/insights?page=1&per_page=20&locale=en&type=per_asset&coin=bitcoin&search=etf&sort=first_reported" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/insights"
);

const params = {
    "page": "1",
    "per_page": "20",
    "locale": "en",
    "type": "per_asset",
    "coin": "bitcoin",
    "search": "etf",
    "sort": "first_reported",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/insights';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '20',
            'locale' => 'en',
            'type' => 'per_asset',
            'coin' => 'bitcoin',
            'search' => 'etf',
            'sort' => 'first_reported',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/insights'
params = {
  'page': '1',
  'per_page': '20',
  'locale': 'en',
  'type': 'per_asset',
  'coin': 'bitcoin',
  'search': 'etf',
  'sort': 'first_reported',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Get an insight

One insight with its full payload — headline, summary, source-article timeline and related coins.

GET

http://localhost/api/v1/insights/{id}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

id

integer required

101

The insight id.

Query parameters

locale

string optional

en

Content language (falls back to English).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/insights/101?locale=en" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/insights/101"
);

const params = {
    "locale": "en",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/insights/101';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'locale' => 'en',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/insights/101'
params = {
  'locale': 'en',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

List alarms

The key owner's alarms, newest first, paginated. Filter by status, direction or notification channel.

GET

http://localhost/api/v1/alarms

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Query parameters

page

integer optional

1

Page number (1-based).

per_page

integer optional

25

Rows per page (1–100, default 25).

status

string optional

active

Filter by state: active or triggered.

direction

string optional

above

Filter by trigger direction: above or below.

notification

string optional

email

Filter by delivery channel: email, push or webhook.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/alarms?page=1&per_page=25&status=active&direction=above&notification=email" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/alarms"
);

const params = {
    "page": "1",
    "per_page": "25",
    "status": "active",
    "direction": "above",
    "notification": "email",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/alarms';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '25',
            'status' => 'active',
            'direction' => 'above',
            'notification' => 'email',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/alarms'
params = {
  'page': '1',
  'per_page': '25',
  'status': 'active',
  'direction': 'above',
  'notification': 'email',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "id": 42,
5            "name": "BTC six figures",
6            "coin": {
7                "slug": "bitcoin",
8                "symbol": "BTC",
9                "name": "Bitcoin"
10            },
11            "metric": "rate",
12            "direction": "above",
13            "target": "100000",
14            "notification": "email",
15            "status": "active",
16            "created_at": "2026-06-21T09:15:00+00:00"
17        }
18    ],
19    "meta": {
20        "current_page": 1,
21        "per_page": 25,
22        "total": 3,
23        "last_page": 1
24    }
25}

Create an alarm

Creates a TARGET alarm on a coin and spends one alarm slot from the key owner's balance. The target is checked against the coin's current value so the alarm cannot self-trigger instantly: an above alarm must target more than the current value, a below alarm less.

POST

http://localhost/api/v1/alarms

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Body parameters

name

string required

BTC six figures

A label for the alarm (max 255 characters).

coin

string required

bitcoin

The coin's slug identifier.

metric

string required

rate

The watched metric: rate, volume or marketcap.

direction

string required

above

Trigger direction: above or below.

target

number required

100000

The threshold value (must sit on the direction side of the coin's current value).

notification

string required

email

Delivery channel: email, push or webhook.

Request

curl --request POST \
    "http://localhost/api/v1/alarms" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"BTC six figures\",
    \"coin\": \"bitcoin\",
    \"metric\": \"rate\",
    \"direction\": \"above\",
    \"target\": 100000,
    \"notification\": \"email\"
}"

const url = new URL(
    "http://localhost/api/v1/alarms"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "name": "BTC six figures",
    "coin": "bitcoin",
    "metric": "rate",
    "direction": "above",
    "target": 100000,
    "notification": "email"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/alarms';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'BTC six figures',
            'coin' => 'bitcoin',
            'metric' => 'rate',
            'direction' => 'above',
            'target' => 100000.0,
            'notification' => 'email',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/alarms'
payload = {
    "name": "BTC six figures",
    "coin": "bitcoin",
    "metric": "rate",
    "direction": "above",
    "target": 100000,
    "notification": "email"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Response

1{
2    "data": {
3        "id": 43,
4        "name": "BTC six figures",
5        "coin": {
6            "slug": "bitcoin",
7            "symbol": "BTC",
8            "name": "Bitcoin"
9        },
10        "metric": "rate",
11        "direction": "above",
12        "target": "100000",
13        "notification": "email",
14        "status": "active",
15        "created_at": "2026-07-03T08:00:00+00:00"
16    }
17}

Delete an alarm

Deletes one of the key owner's alarms and refunds the alarm slot it consumed.

DELETE

http://localhost/api/v1/alarms/{id}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

id

integer required

42

The alarm id.

Request

curl --request DELETE \
    "http://localhost/api/v1/alarms/42" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/alarms/42"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/alarms/42';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/alarms/42'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Response

1{
2    "data": {
3        "deleted": true
4    }
5}

List webhook endpoints

The key owner's webhook endpoints, newest first. Signing secrets are never included — each secret is shown exactly once, at creation.

GET

http://localhost/api/v1/webhooks

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/webhooks" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/webhooks"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/webhooks';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/webhooks'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "data": [
3        {
4            "id": 7,
5            "url": "https://example.com/webhooks/bitculator",
6            "events": [
7                "alarm.triggered"
8            ],
9            "status": "active",
10            "consecutive_failures": 0,
11            "disabled_at": null,
12            "created_at": "2026-06-20T10:00:00+00:00"
13        }
14    ]
15}

Create a webhook endpoint

Registers an HTTPS endpoint (max 5 per account) for event deliveries. The response includes the signing secret — the ONLY time it is ever shown, so store it immediately.

POST

http://localhost/api/v1/webhooks

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Body parameters

url

string required

https://example.com/webhooks/bitculator

The HTTPS delivery URL. Public hosts only — internal/private addresses are rejected.

events

string[] required

["alarm.triggered"]

Events to subscribe to. Allowed values: alarm.triggered.

Request

curl --request POST \
    "http://localhost/api/v1/webhooks" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"url\": \"https:\\/\\/example.com\\/webhooks\\/bitculator\",
    \"events\": [
        \"alarm.triggered\"
    ]
}"

const url = new URL(
    "http://localhost/api/v1/webhooks"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "url": "https:\/\/example.com\/webhooks\/bitculator",
    "events": [
        "alarm.triggered"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/webhooks';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'url' => 'https://example.com/webhooks/bitculator',
            'events' => ['alarm.triggered'],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/webhooks'
payload = {
    "url": "https:\/\/example.com\/webhooks\/bitculator",
    "events": [
        "alarm.triggered"
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Response

1{
2    "data": {
3        "id": 8,
4        "url": "https://example.com/webhooks/bitculator",
5        "events": [
6            "alarm.triggered"
7        ],
8        "status": "active",
9        "consecutive_failures": 0,
10        "disabled_at": null,
11        "created_at": "2026-07-03T08:00:00+00:00",
12        "secret": "whsec_k5cQ1x9jJ2mW7pR4tY8uB3nV6zA0sD5f"
13    }
14}

Delete a webhook endpoint

Deletes one of the key owner's webhook endpoints. Pending deliveries to it are abandoned.

DELETE

http://localhost/api/v1/webhooks/{id}

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

id

integer required

7

The webhook endpoint id.

Request

curl --request DELETE \
    "http://localhost/api/v1/webhooks/7" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/webhooks/7"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/webhooks/7';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/webhooks/7'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('DELETE', url, headers=headers)
response.json()

Response

1{
2    "data": {
3        "deleted": true
4    }
5}

Send a test event

Fires a signed alarm.triggered test event (test: true in the payload, real signature headers) so receivers can be verified end-to-end.

POST

http://localhost/api/v1/webhooks/{id}/test

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

id

integer required

7

The webhook endpoint id.

Request

curl --request POST \
    "http://localhost/api/v1/webhooks/7/test" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/webhooks/7/test"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/webhooks/7/test';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/webhooks/7/test'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers)
response.json()

Response

1{
2    "data": {
3        "queued": true
4    }
5}

Webhook delivery log

The endpoint's delivery attempts (kept 30 days), newest first, paginated.

GET

http://localhost/api/v1/webhooks/{id}/deliveries

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

Path parameters

id

integer required

7

The webhook endpoint id.

Query parameters

page

integer optional

1

Page number (1-based).

per_page

integer optional

25

Rows per page (1–100, default 25).

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/webhooks/7/deliveries?page=1&per_page=25" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/webhooks/7/deliveries"
);

const params = {
    "page": "1",
    "per_page": "25",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/webhooks/7/deliveries';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'page' => '1',
            'per_page' => '25',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/webhooks/7/deliveries'
params = {
  'page': '1',
  'per_page': '25',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers, params=params)
response.json()

Response

1{
2    "data": [
3        {
4            "id": 311,
5            "event": "alarm.triggered",
6            "response_status": 200,
7            "error": null,
8            "attempts": 1,
9            "delivered_at": "2026-07-02T21:14:09+00:00",
10            "created_at": "2026-07-02T21:14:08+00:00"
11        }
12    ],
13    "meta": {
14        "current_page": 1,
15        "per_page": 25,
16        "total": 6,
17        "last_page": 1,
18        "retention": "30 days"
19    }
20}

OpenAPI spec

The machine-readable OpenAPI 3 document for this API, as JSON — point codegen or API tooling at this URL. Public: no key required.

GET

http://localhost/api/v1/openapi.json

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/openapi.json" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/openapi.json"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/openapi.json';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/openapi.json'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Ping

An authenticated no-op for verifying a Data API key end-to-end (auth.api → per-plan burst throttle → monthly quota). It counts against the quota like any other call.

GET

http://localhost/api/v1/ping

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/ping" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/ping"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/ping';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/ping'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "data": {
3        "status": "ok",
4        "plan": "free"
5    }
6}

Key usage & quota

Usage introspection for the calling key's owner: the Data API plan, its monthly limit, used and remaining (always matching the X-Quota-* headers), the current period window, and per-endpoint / per-token breakdowns. Embed-widget usage has its own plan and pool — it never appears here.

GET

http://localhost/api/v1/usage

Authorization

Create a key in the developer console →

Bearer

bc_••••••••••••••••

Keys are Bearer-only and carry the data-api ability — keep them server-side.

GET request — no request body.

Request

curl --request GET \
    --get "http://localhost/api/v1/usage" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "http://localhost/api/v1/usage"
);

const headers = {
    "Authorization": "Bearer {YOUR_API_KEY}",
    "Content-Type": "application/json",
    "Accept": "application/json",
};


fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());

$client = new \GuzzleHttp\Client();
$url = 'http://localhost/api/v1/usage';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'http://localhost/api/v1/usage'
headers = {
  'Authorization': 'Bearer {YOUR_API_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('GET', url, headers=headers)
response.json()

Response

1{
2    "data": {
3        "plan": "free",
4        "limit": 10000,
5        "used": 29,
6        "remaining": 9971,
7        "period_start": "2026-06-15",
8        "period_end": "2026-07-15T00:00:00+00:00",
9        "burst_per_minute": 60,
10        "endpoints": [
11            {
12                "endpoint": "GET api/v1/prices",
13                "requests": 18
14            },
15            {
16                "endpoint": "GET api/v1/global",
17                "requests": 11
18            }
19        ],
20        "tokens": [
21            {
22                "id": 12,
23                "name": "production",
24                "kind": "data-api",
25                "requests": 29,
26                "last_used_at": "2026-07-02T21:14:09+00:00",
27                "revoked": false
28            }
29        ]
30    },
31    "meta": {
32        "note": "Endpoint and token breakdowns are flushed from the buffer every minute and can trail `used` slightly."
33    }
34}

Bitculator Data API

Authentication

Coins

List coins

Query parameters

Request

Recently added coins

Query parameters

Request

Top gainers

Query parameters

Request

Top losers

Query parameters

Request

Trending coins

Query parameters

Request

Get coin detail

Path parameters

Query parameters

Request

Candle history

Path parameters

Query parameters

Request

Marketcap history

Path parameters

Query parameters

Request

Coin sparkline

Path parameters

Query parameters

Request

Prices

Get prices

Query parameters

Request

Get a coin price

Path parameters

Query parameters

Request

Historical price

Query parameters

Request

Markets

Coin markets

Path parameters

Query parameters

Request

Coin trading symbols

Path parameters

Request

List tickers

Query parameters

Request

List pairs

Query parameters

Request

Get pair detail

Path parameters

Request

Exchanges

List exchanges

Query parameters

Request

Get exchange detail

Path parameters

Request

Get exchange trust score

Path parameters

Request

Exchange history

Path parameters

Query parameters

Request

Exchange sparkline

Path parameters

Query parameters

Request