Account & Credits

Authentication

All account endpoints authenticate with your standard API key passed in the X-AUTHAPI-Key header — the same key you use for data requests, available in your dashboard. No browser session or cookie is needed.

Base URL

Use case: a self-tuning rate limiter

The most common reason to call these endpoints is to drive a client-side rate limiter from a horizontally-scaled service. Because limit_per_minute is tier-based, it shifts as your balance crosses tier boundaries — a hardcoded value in your config will drift out of sync, leaving you either over-throttling (wasting throughput) or hitting 429 responses and failing jobs.

Instead, read the live limit from /credits/tier/k/ and refresh it periodically. Your limiter then always matches your real allowance:

Python

import time, threading, requests

API_KEY = "your_api_key_here"
BASE = "https://linkdapi.com/api/i/v1"
HEADERS = {"X-AUTHAPI-Key": API_KEY}

_limit = {"per_minute": 7}  # safe default until first refresh

def refresh_rate_limit():
    """Pull the live per-minute limit for the current tier."""
    r = requests.get(f"{BASE}/credits/tier/k/", headers=HEADERS, timeout=10)
    data = r.json()["data"]
    _limit["per_minute"] = data["current_tier"]["limit_per_minute"]
    return _limit["per_minute"]

# Refresh on startup, then every few minutes so the limiter
# tracks tier changes as credits are consumed or topped up.
def keep_in_sync(interval=300):
    while True:
        try:
            refresh_rate_limit()
        except Exception:
            pass  # keep the last known value on transient errors
        time.sleep(interval)

refresh_rate_limit()
threading.Thread(target=keep_in_sync, daemon=True).start()

# ... your limiter reads _limit["per_minute"] when allocating tokens

Node.js

const BASE = "https://linkdapi.com/api/i/v1";
const HEADERS = { "X-AUTHAPI-Key": process.env.LINKDAPI_KEY };

let limitPerMinute = 7; // safe default until first refresh

async function refreshRateLimit() {
  const res = await fetch(`${BASE}/credits/tier/k/`, { headers: HEADERS });
  const { data } = await res.json();
  limitPerMinute = data.current_tier.limit_per_minute;
  return limitPerMinute;
}

// Refresh on boot, then every 5 minutes.
await refreshRateLimit();
setInterval(() => refreshRateLimit().catch(() => {}), 5 * 60 * 1000);

Best practices

• Cache, don't poll per request. Read the limit once on startup and refresh on an interval (every 1–5 minutes is plenty). The tier only changes when your balance crosses a boundary.
• Refresh on a 429. If you do hit Too many requests, immediately re-read /credits/tier/k/ — your tier likely dropped — then back off and resume at the new limit.
• Keep a safe default. Seed your limiter with a conservative value so a failed refresh never lets it run unbounded.
• Watch next_tier.credits_needed. Surface it in your monitoring to know exactly how many credits separate you from a higher limit, and to fire low-balance alerts before jobs start failing.
• Stay just under the limit. Target ~90% of limit_per_minute to absorb clock skew across your horizontally-scaled instances.