Bitculator Data API

List coins

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/api/v1/coins/bitcoin/symbols" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/api/v1/pairs/1" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/api/v1/exchanges/binance-exchange" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Starter

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Starter

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/api/v1/wallets/frostsnap" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/api/v1/global" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Starter

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

https://bitculator.com/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 "https://bitculator.com/api/v1/global/heatmap" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Starter

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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()

Fear & Greed index

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Starter

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Starter

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Pro

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

GET

https://bitculator.com/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 "https://bitculator.com/api/v1/sentiment/indicators" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Pro

The multi-indicator snapshot - every indicator category's latest state (bullish/bearish/sheepish…), score and raw data, in one payload. Ideal for a dashboard at-a-glance read; use the dedicated per-indicator endpoints below for full daily history.

GET

https://bitculator.com/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 "https://bitculator.com/api/v1/coins/bitcoin/indicators" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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}

RSI (Relative Strength Index)

Starter

Daily Relative Strength Index - a momentum oscillator bounded 0–100 that measures the speed and magnitude of recent price moves. Above 70 is conventionally overbought, below 30 oversold. Windows: 7, 14, 21, 28 days (default 14) - the 21- and 28-day windows require the Starter plan or higher. Young coins return leading warm-up nulls.

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/rsi

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

integer optional

14

Window length - one of 7, 14, 21, 28 (default 14).

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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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}

Stochastic RSI

Pro

Daily Stochastic RSI - applies the stochastic oscillator to RSI itself, giving a faster, more sensitive 0–100 momentum read with %K and %D lines that cross to signal turns. Windows: 7, 14, 21, 28 days (default 14) - the 21- and 28-day windows require the Starter plan or higher.

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/stoch-rsi

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

integer optional

14

Window length - one of 7, 14, 21, 28 (default 14).

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/stoch-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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/stoch-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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/stoch-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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/stoch-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            "k": 18.4,
6            "d": 22.1
7        }
8    ],
9    "meta": {
10        "coin": "bitcoin",
11        "indicator": "stoch-rsi",
12        "period": 14,
13        "count": 1
14    }
15}

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

SMA (Simple Moving Average)

Starter

Daily Simple Moving Average - the arithmetic mean of the closing price over the window, the classic trend baseline traders read for support, resistance and golden/death crosses. Windows: 50, 100, 200 days (default 50). Values are decimal strings on the price scale.

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/sma

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

integer optional

50

Window length - one of 50, 100, 200 (default 50).

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/sma?period=50&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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/sma"
);

const params = {
    "period": "50",
    "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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/sma';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'period' => '50',
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/sma'
params = {
  'period': '50',
  '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": "63120.44821000"
6        }
7    ],
8    "meta": {
9        "coin": "bitcoin",
10        "indicator": "sma",
11        "period": 50,
12        "count": 1
13    }
14}

CCI (Commodity Channel Index)

Starter

Daily Commodity Channel Index - measures how far price has deviated from its statistical mean; readings beyond ±100 flag strong trends or potential reversals. Windows: 20, 50, 100 days (default 20).

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/cci

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

integer optional

20

Window length - one of 20, 50, 100 (default 20).

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/cci?period=20&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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/cci"
);

const params = {
    "period": "20",
    "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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/cci';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'period' => '20',
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/cci'
params = {
  'period': '20',
  '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": -83.5
6        }
7    ],
8    "meta": {
9        "coin": "bitcoin",
10        "indicator": "cci",
11        "period": 20,
12        "count": 1
13    }
14}

MFI (Money Flow Index)

Pro

Daily Money Flow Index - a volume-weighted RSI (0–100) that factors trading volume into momentum, often called "volume RSI"; above 80 overbought, below 20 oversold. Windows: 7, 14, 28 days (default 14).

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/mfi

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

integer optional

14

Window length - one of 7, 14, 28 (default 14).

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/mfi?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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/mfi"
);

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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/mfi';
$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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/mfi'
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": 57.2
6        }
7    ],
8    "meta": {
9        "coin": "bitcoin",
10        "indicator": "mfi",
11        "period": 14,
12        "count": 1
13    }
14}

Williams %R

Pro

Daily Williams %R - a momentum oscillator bounded −100–0 that maps where the close sits within the recent high-low range; above −20 overbought, below −80 oversold. Windows: 14, 20, 50 days (default 14).

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/williams-r

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

integer optional

14

Window length - one of 14, 20, 50 (default 14).

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/williams-r?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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/williams-r"
);

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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/williams-r';
$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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/williams-r'
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": -72.4
6        }
7    ],
8    "meta": {
9        "coin": "bitcoin",
10        "indicator": "williams-r",
11        "period": 14,
12        "count": 1
13    }
14}

Price volatility

Pro

Daily price-volatility index - the dispersion of daily returns over the window, a normalized read on how choppy price action has been. Windows: 7, 14, 30 days (default 7) - the 30-day window requires the Starter plan or higher.

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/price-volatility

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

integer optional

7

Window length - one of 7, 14, 30 (default 7).

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/price-volatility?period=7&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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/price-volatility"
);

const params = {
    "period": "7",
    "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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/price-volatility';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'period' => '7',
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/price-volatility'
params = {
  'period': '7',
  '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": 3.18
6        }
7    ],
8    "meta": {
9        "coin": "bitcoin",
10        "indicator": "price-volatility",
11        "period": 7,
12        "count": 1
13    }
14}

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

Volume volatility

Starter

Daily volume-volatility index - the dispersion of daily trading volume over the window, a read on how erratic participation has been. Windows: 7, 14, 30 days (default 7) - the 30-day window requires the Starter plan or higher.

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/volume-volatility

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

integer optional

7

Window length - one of 7, 14, 30 (default 7).

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/volume-volatility?period=7&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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/volume-volatility"
);

const params = {
    "period": "7",
    "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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/volume-volatility';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'period' => '7',
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/volume-volatility'
params = {
  'period': '7',
  '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": 12.6
6        }
7    ],
8    "meta": {
9        "coin": "bitcoin",
10        "indicator": "volume-volatility",
11        "period": 7,
12        "count": 1
13    }
14}

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

MACD

Pro

Daily MACD (Moving Average Convergence Divergence) - the 12/26 EMA spread with a 9-period signal line and histogram, a staple trend-and-momentum indicator read for signal-line crossovers and zero-line shifts. Returns macd, signal and histogram as decimal strings. No window parameter.

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/macd

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

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/macd?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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/macd"
);

const params = {
    "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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/macd';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/macd'
params = {
  '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            "macd": "-2811.87686067",
6            "signal": "-3364.35539147",
7            "histogram": "552.47853080"
8        }
9    ],
10    "meta": {
11        "coin": "bitcoin",
12        "indicator": "macd",
13        "period": null,
14        "count": 1
15    }
16}

OBV (On-Balance Volume)

Pro

Daily On-Balance Volume - a cumulative volume line that adds volume on up days and subtracts it on down days, tracking net buying vs. selling pressure and confirming (or diverging from) price trends. Single decimal-string series.

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/obv

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

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/obv?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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/obv"
);

const params = {
    "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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/obv';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/obv'
params = {
  '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": "1755907904411"
6        }
7    ],
8    "meta": {
9        "coin": "bitcoin",
10        "indicator": "obv",
11        "period": null,
12        "count": 1
13    }
14}

ADX (Average Directional Index)

Starter

Daily ADX with +DI/−DI - measures trend strength (adx) and direction (the plus_di/minus_di directional indicators). ADX above 25 signals a strong trend regardless of direction; the DI crossover signals which way. Single series, no window parameter.

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/adx

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

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/adx?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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/adx"
);

const params = {
    "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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/adx';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/adx'
params = {
  '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            "adx": 27.3,
6            "plus_di": 22.1,
7            "minus_di": 15.8
8        }
9    ],
10    "meta": {
11        "coin": "bitcoin",
12        "indicator": "adx",
13        "period": null,
14        "count": 1
15    }
16}

VWAP (Volume-Weighted Average Price)

Pro

Daily VWAP - the average price weighted by volume, a core fair-value and execution reference; price above VWAP reads bullish, below bearish. Single decimal-string series, no window parameter.

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/vwap

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

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/vwap?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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/vwap"
);

const params = {
    "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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/vwap';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/vwap'
params = {
  '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": "62880.10000000"
6        }
7    ],
8    "meta": {
9        "coin": "bitcoin",
10        "indicator": "vwap",
11        "period": null,
12        "count": 1
13    }
14}

CMF (Chaikin Money Flow)

Starter

Daily Chaikin Money Flow - sums money-flow volume over the period to gauge accumulation vs. distribution; positive reads as net buying pressure, negative as selling. Bounded around ±1. Single series, no window parameter.

GET

https://bitculator.com/api/v1/coins/{slug}/indicators/cmf

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

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 "https://bitculator.com/api/v1/coins/bitcoin/indicators/cmf?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(
    "https://bitculator.com/api/v1/coins/bitcoin/indicators/cmf"
);

const params = {
    "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 = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/cmf';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'start' => '2026-06-01',
            'end' => '2026-06-30',
            'limit' => '30',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));

import requests
import json

url = 'https://bitculator.com/api/v1/coins/bitcoin/indicators/cmf'
params = {
  '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": 0.14
6        }
7    ],
8    "meta": {
9        "coin": "bitcoin",
10        "indicator": "cmf",
11        "period": null,
12        "count": 1
13    }
14}

Convert between assets

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/api/v1/fiats" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/api/v1/rates" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

Pure math - no market data. Note that the rate applies PER COMPOUNDING PERIOD (the web calculator's convention), not per year.

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

Borrow against crypto vs sell it - compares both scenarios using the coin's CURRENT price. Informational projection, not financial advice.

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

Pure math - staking rewards with optional compounding and a validator commission. No market data is read.

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

Curated videos attached to a coin (the coin page's Videos tab), paginated.

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

The coin's insight timeline - the same payload the asset page's insights panel uses, windowed by offset/limit.

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

Registers a thumbs-up/down on an article - the same counters the web's helpful buttons use. Per-key throttling applies upstream.

POST

https://bitculator.com/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 \
    "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

One curated video with its YouTube id, title, type, duration and the coins/exchanges/wallets it is attached to.

GET

https://bitculator.com/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 "https://bitculator.com/api/v1/videos/87" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

One insight with its full payload - headline, summary, source-article timeline and related coins.

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

The key owner's alarms, newest first, paginated. Filter by status, direction or notification channel.

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 \
    "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

Deletes one of the key owner's alarms and refunds the alarm slot it consumed.

DELETE

https://bitculator.com/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 \
    "https://bitculator.com/api/v1/alarms/42" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

The key owner's webhook endpoints, newest first. Signing secrets are never included - each secret is shown exactly once, at creation.

GET

https://bitculator.com/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 "https://bitculator.com/api/v1/webhooks" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 \
    "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

Deletes one of the key owner's webhook endpoints. Pending deliveries to it are abandoned.

DELETE

https://bitculator.com/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 \
    "https://bitculator.com/api/v1/webhooks/7" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

Fires a signed alarm.triggered test event (test: true in the payload, real signature headers) so receivers can be verified end-to-end.

POST

https://bitculator.com/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 \
    "https://bitculator.com/api/v1/webhooks/7/test" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

The endpoint's delivery attempts (kept 30 days), newest first, paginated.

GET

https://bitculator.com/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 "https://bitculator.com/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(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

The machine-readable OpenAPI 3 document for this API, as JSON - point codegen or API tooling at this URL. Public: no key required.

GET

https://bitculator.com/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 "https://bitculator.com/api/v1/openapi.json" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/api/v1/ping" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Free

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

https://bitculator.com/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 "https://bitculator.com/api/v1/usage" \
    --header "Authorization: Bearer {YOUR_API_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"

const url = new URL(
    "https://bitculator.com/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 = 'https://bitculator.com/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 = 'https://bitculator.com/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

Client libraries

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