Getting Started with Smart Money API

Smart Money API provides real-time access to cryptocurrency whale movements, derivatives intelligence, and on-chain analysis across Bybit, Binance, and Hyperliquid. This guide walks you through account setup, authentication, making your first API request, and understanding the core data types.

Table of Contents

What is Smart Money API
Creating Your Account
Generating API Keys
Authentication Methods
Base URL and Endpoints
Making Your First Request
Understanding API Responses
Error Handling
Next Steps

What is Smart Money API

Smart Money API is a cryptocurrency intelligence platform providing real-time market signals from whale wallets and institutional flows. Unlike basic market data APIs, Smart Money API aggregates data from three major derivatives exchanges and combines it with on-chain intelligence to create actionable trading signals.

The platform automatically discovers and tracks 500+ whale wallets from Hyperliquid, monitors derivatives funding rates across exchanges, and analyzes stablecoin flows to identify smart money movements. All data arrives with confirmation scores indicating signal strength.

Core Capabilities

Real-Time Whale Tracking: Monitor 500+ discovered whale wallets across Hyperliquid, Binance, and Bybit
Derivatives Intelligence: Funding rates, open interest, liquidations, and perpetual contract data
On-Chain Analysis: Exchange flows, stablecoin movements, and miner behavior
Confirmation Scores: Multi-signal confidence metrics combining blockchain and derivatives data
WebSocket Streaming: Real-time data delivery with sub-100ms latency
Historical Data: 2+ years of stored data available for backtesting strategies

Creating Your Account

Start by creating a Smart Money API account. This grants you access to the dashboard, API key management, and usage analytics.

Account Creation Steps

Visit https://smartmoneyapi.com/signup
Enter your email address and create a strong password
Verify your email by clicking the confirmation link
Complete your profile with display name (optional)
Select your initial plan (Free, Trader, Pro, or Enterprise)
For paid plans, add payment method via Stripe
Activate your account

Free Plan Includes: 10 API requests per day, BTC only, limited to basic endpoints. Perfect for testing and small-scale projects.

After account creation, you'll access your dashboard where you can manage API keys, monitor usage, configure webhooks, and view usage analytics.

Generating API Keys

API keys authenticate your requests. Smart Money API uses two-key authentication: a public key for identification and a secret key for request signing.

API Key Generation Process

Log into your Smart Money API dashboard
Navigate to Settings → API Keys
Click "Generate New Key"
Choose key permissions (read-only recommended for development)
Set key restrictions (IP whitelist optional)
Copy both public and secret keys immediately
Store secret key securely (never commit to version control)

Security Best Practice: Use separate API keys for development, testing, and production. Enable IP whitelisting to restrict key access to your infrastructure.

You can generate multiple keys with different permissions. For example, create one read-only key for public dashboards and a full-access key for your trading bot in a secure server environment.

Authentication Methods

Smart Money API supports two authentication approaches: header-based (simple) and HMAC-SHA256 signed requests (secure).

Method 1: API Key Header (Simple)

Ideal for development and non-sensitive environments:

        CURL
      
curl -H "X-API-Key: your_public_key" \
  https://api.smartmoneyapi.com/v1/whales/top-positions

Method 2: HMAC-SHA256 Signing (Secure)

Recommended for production systems. Signs requests with your secret key to prove ownership:

        PYTHON
      

import hmac
import hashlib
import time
import requests

def create_signed_request(endpoint, method='GET', params=None):
    """Create HMAC-SHA256 signed request"""
    public_key = 'your_public_key'
    secret_key = 'your_secret_key'
    timestamp = str(int(time.time() * 1000))

    # Build signature string
    path = f'/v1{endpoint}'
    message = f'{method}{path}{timestamp}'

    if params:
        query_string = '&'.join([f'{k}={v}' for k, v in params.items()])
        message += f'?{query_string}'

    # Create HMAC signature
    signature = hmac.new(
        secret_key.encode(),
        message.encode(),
        hashlib.sha256
    ).hexdigest()

    # Make request with signature
    headers = {
        'X-API-Key': public_key,
        'X-Timestamp': timestamp,
        'X-Signature': signature
    }

    url = f'https://api.smartmoneyapi.com{path}'
    response = requests.request(
        method,
        url,
        params=params,
        headers=headers
    )

    return response.json()
      

Base URL and Endpoints

All Smart Money API requests use the following base URL:

        TEXT
      
https://api.smartmoneyapi.com/v1

Endpoints are organized by functionality. Here are the primary categories:

Main Endpoint Categories

/whales/ - Whale wallet tracking and positions
/derivatives/ - Funding rates, open interest, liquidations
/onchain/ - Exchange flows, stablecoin movements, miner data
/signals/ - Confirmation scores and composite signals
/market/ - Current price, OHLCV data across exchanges
/historical/ - Backtesting data and historical analysis

Each endpoint accepts GET or POST requests with query parameters or JSON bodies. Responses are always returned in JSON format with standardized structures.

Making Your First Request

Let's retrieve the top whale positions on Hyperliquid as your first API call. This endpoint returns the most active whale wallets and their current positions.

        CURL
      
curl -X GET "https://api.smartmoneyapi.com/v1/whales/top-positions" \
  -H "X-API-Key: your_public_key" \
  -H "Content-Type: application/json"

        PYTHON
      

import requests

api_key = 'your_public_key'
headers = {'X-API-Key': api_key}

response = requests.get(
    'https://api.smartmoneyapi.com/v1/whales/top-positions',
    headers=headers
)

data = response.json()
print(f"Status: {response.status_code}")
print(f"Top Whales: {len(data['whales'])} positions")

for whale in data['whales'][:5]:
    print(f"Wallet: {whale['address']}")
    print(f"Balance: {whale['total_usd_value']} USD")
    print(f"Primary Position: {whale['largest_position']['asset']}")
      

        JAVASCRIPT
      

const API_KEY = 'your_public_key';

async function getTopWhales() {
  try {
    const response = await fetch(
      'https://api.smartmoneyapi.com/v1/whales/top-positions',
      {
        method: 'GET',
        headers: {
          'X-API-Key': API_KEY,
          'Content-Type': 'application/json'
        }
      }
    );

    const data = await response.json();

    console.log(`Found ${data.whales.length} whale positions`);

    data.whales.slice(0, 5).forEach(whale => {
      console.log(`Wallet: ${whale.address}`);
      console.log(`USD Value: $${whale.total_usd_value}`);
      console.log(`Main Asset: ${whale.largest_position.asset}`);
    });

    return data;
  } catch (error) {
    console.error('Error fetching whale data:', error);
  }
}

getTopWhales();
      

Understanding API Responses

All Smart Money API responses follow a consistent JSON structure. Understanding this structure helps you parse data correctly in your applications.

Standard Response Format

Successful requests return HTTP 200 with this structure:

        JSON
      

{
  "success": true,
  "timestamp": "2026-03-21T14:30:45Z",
  "data": {
    // Endpoint-specific data
  },
  "meta": {
    "request_id": "req_abc123xyz",
    "api_version": "v1",
    "rate_limit": {
      "limit": 200,
      "remaining": 189,
      "reset_timestamp": 1711000245
    }
  }
}
      

Key response fields:

success: Boolean indicating request success
timestamp: UTC timestamp of response generation
data: Endpoint-specific payload
meta: Rate limit info, request ID, API version

The rate_limit object shows your current usage. When remaining reaches 0, requests return 429 Too Many Requests. Track the reset_timestamp to know when your limit refreshes.

Error Handling

When requests fail, Smart Money API returns error responses with informative messages. Implement proper error handling to build robust applications.

Common Error Codes

400 Bad Request: Invalid parameters or malformed request
401 Unauthorized: Missing or invalid API key
403 Forbidden: API key lacks permission for this endpoint
404 Not Found: Endpoint or resource doesn't exist
429 Too Many Requests: Rate limit exceeded
500 Internal Server Error: Server error (rare, contact support)

        PYTHON
      

import requests
from time import sleep

def call_api_with_retry(endpoint, max_retries=3):
    """Call API with error handling and exponential backoff"""
    api_key = 'your_public_key'
    headers = {'X-API-Key': api_key}
    url = f'https://api.smartmoneyapi.com/v1{endpoint}'

    for attempt in range(max_retries):
        try:
            response = requests.get(url, headers=headers, timeout=10)

            # Check rate limit
            remaining = int(response.headers.get('X-RateLimit-Remaining', 0))
            if remaining < 5:
                print(f"Warning: Only {remaining} requests remaining")

            # Handle success
            if response.status_code == 200:
                return response.json()

            # Handle rate limiting
            elif response.status_code == 429:
                reset_time = int(response.headers.get('X-RateLimit-Reset', 0))
                wait_seconds = reset_time - time.time()
                print(f"Rate limited. Waiting {wait_seconds} seconds...")
                sleep(max(wait_seconds, 1))
                continue

            # Handle client errors
            elif 400 <= response.status_code < 500:
                error_data = response.json()
                print(f"Client Error: {error_data['error']['message']}")
                return None

            # Handle server errors
            else:
                print(f"Server Error: {response.status_code}")
                if attempt < max_retries - 1:
                    wait_time = 2 ** attempt  # Exponential backoff
                    print(f"Retrying in {wait_time} seconds...")
                    sleep(wait_time)
                    continue
                return None

        except requests.exceptions.Timeout:
            print("Request timeout, retrying...")
            if attempt < max_retries - 1:
                sleep(2 ** attempt)
                continue
            return None
        except requests.exceptions.ConnectionError:
            print("Connection error, retrying...")
            if attempt < max_retries - 1:
                sleep(2 ** attempt)
                continue
            return None

    return None
      

Next Steps

Now that you understand the basics, explore these advanced topics:

Recommended Learning Path

Explore Endpoints: Read the full API documentation to discover all available endpoints
Language Integration: Follow the Python or JavaScript integration guide for your preferred language
Real-Time Data: Learn WebSocket streaming to receive live data updates
Build Applications: Create trading bots, dashboards, or analysis tools
Optimization: Review rate limiting best practices and caching strategies

Pro Tip: Start with the free plan to test your integration. Once you've validated your use case, upgrade to a paid plan for production use with higher rate limits and advanced features.

Check out our comprehensive guides on Python integration, JavaScript integration, and WebSocket streaming to dive deeper into implementation details.

Start Building With Smart Money API

Access real-time whale tracking, derivatives intelligence, and on-chain analysis. Create your account and generate your first API key today.

Get Your API Key