Bitculator Data API

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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


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

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

import requests
import json

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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


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

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

import requests
import json

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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


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

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

import requests
import json

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

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

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

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

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

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

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

import requests
import json

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

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

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

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

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


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

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

import requests
import json

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

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

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

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

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


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