How to Use a Crypto Intelligence API: A Developer's Guide to AIOKA

Why Developers Use Crypto Intelligence APIs

Building a crypto trading tool from scratch is hard. You need data providers for on-chain metrics, macro indicators, sentiment data, and price feeds. You need models to analyze the data. You need a system to synthesize multiple signals into actionable verdicts.

Or you can use AIOKA's API - and get all of that in a single REST endpoint.

AIOKA's API gives developers access to:

Here's everything you need to get started.

Authentication

AIOKA uses API key authentication via the X-API-Key header.

Getting your key:

Making your first request:

curl https://api.aioka.io/v1/verdict/latest \
  -H "X-API-Key: aik_free_your_key_here"

Python example:

import requests

API_KEY = "aik_free_your_key_here"
BASE_URL = "https://api.aioka.io"

headers = {"X-API-Key": API_KEY}

response = requests.get(
    f"{BASE_URL}/v1/verdict/latest",
    headers=headers
)
verdict = response.json()
print(f"Verdict: {verdict['ruling']} ({verdict['confidence']*100:.0f}% confidence)")

Core Endpoints

GET /v1/verdict/latest

Returns the most recent AI Council verdict. Available on all tiers including Free.

Response:

{
  "ruling": "ACCUMULATE",
  "confidence": 0.76,
  "score": 0.62,
  "btc_price": 71771.0,
  "timestamp": "2026-04-10T09:15:00Z",
  "council_ruling": "BUY",
  "council_confidence": 0.76,
  "council_consensus": "STRONG",
  "council_mode": "council",
  "agents": [
    {"name": "CHAIN ORACLE", "vote": "BUY", "confidence": 0.82},
    {"name": "MACRO SAGE", "vote": "BUY", "confidence": 0.78},
    {"name": "SENTIMENT MONK", "vote": "BUY", "confidence": 0.78},
    {"name": "TECH HAWK", "vote": "BUY", "confidence": 0.72},
    {"name": "LIQUIDITY GUARDIAN", "vote": "BUY", "confidence": 0.78},
    {"name": "RISK SHIELD", "vote": "REDUCE", "confidence": 0.78}
  ],
  "cached": false,
  "cache_ttl_seconds": 60
}

Key fields:

GET /v1/regime/current

Returns the current market regime classification.

{
  "regime": "WHALE_ACCUMULATION",
  "confidence": 0.82,
  "timestamp": "2026-04-10T09:00:00Z"
}

GET /v1/signals/latest

Returns the current values of all 27 market signals. Requires Basic tier ($49/mo).

{
  "signals": {
    "MVRV_Z": -2.01,
    "SOPR": 1.0000,
    "NUPL": 0.2383,
    "BTC_EXCHANGE_FLOW": 3029.45,
    "FEAR_GREED_INDEX": 14.0,
    "BTC_USD": 71771.0,
    "EMA_200": 69536.0,
    "SSR_INDEX": 5.42,
    "BTC_DOMINANCE": 56.99
  },
  "timestamp": "2026-04-10T09:15:00Z"
}

GET /v1/ghost/stats

Returns Ghost Trader's current track record. Public endpoint, no auth required.

{
  "validated_trades": 3,
  "target": 10,
  "total_pnl": 155.77,
  "win_rate": 66.7,
  "since": "2026-04-07"
}

Rate Limits

| Tier | Daily Calls | Rate Limit |

|------|------------|------------|

| Free | 10 | 10/min |

| Basic ($49/mo) | 1,000 | 60/min |

| Pro ($199/mo) | 10,000 | 300/min |

Rate limit headers are included in every response:

X-RateLimit-Limit: 10
X-RateLimit-Remaining: 7
X-RateLimit-Reset: 1712749200

Building a Simple Trading Bot

Here's a minimal Python example that checks the council verdict and alerts when conditions are favorable:

import requests
import time

API_KEY = "aik_pro_your_key_here"
BASE_URL = "https://api.aioka.io"
headers = {"X-API-Key": API_KEY}

def check_conditions():
    # Get latest verdict
    verdict_resp = requests.get(
        f"{BASE_URL}/v1/verdict/latest", 
        headers=headers
    ).json()
    
    # Get current regime
    regime_resp = requests.get(
        f"{BASE_URL}/v1/regime/current",
        headers=headers
    ).json()
    
    ruling = verdict_resp.get("council_ruling")
    confidence = verdict_resp.get("council_confidence", 0)
    consensus = verdict_resp.get("council_consensus")
    council_mode = verdict_resp.get("council_mode")
    regime = regime_resp.get("regime")
    
    # Check AIOKA's entry conditions
    conditions = {
        "bullish_verdict": ruling in ["BUY", "ACCUMULATE"],
        "high_confidence": confidence >= 0.75,
        "strong_consensus": consensus in ["STRONG", "MODERATE"],
        "full_council": council_mode == "council",
        "good_regime": regime in ["WHALE_ACCUMULATION", "ACCUMULATION", "BULL_MARKET"]
    }
    
    conditions_met = sum(conditions.values())
    
    print(f"Verdict: {ruling} ({confidence*100:.0f}%)")
    print(f"Regime: {regime}")
    print(f"Conditions met: {conditions_met}/5")
    
    if conditions_met >= 4:
        print("HIGH CONVICTION SETUP - all conditions favorable")
    elif conditions_met >= 3:
        print("MODERATE SETUP - conditions mostly favorable")
    else:
        print("WAITING - conditions not yet aligned")

# Check every 5 minutes
while True:
    check_conditions()
    time.sleep(300)

Backtesting With Historical Data

Pro tier subscribers can access 90 days of verdict history for backtesting:

import requests
import pandas as pd

API_KEY = "aik_pro_your_key_here"
headers = {"X-API-Key": API_KEY}

# Get verdict history
history = requests.get(
    "https://api.aioka.io/v1/verdict/history",
    headers=headers,
    params={"days": 90}
).json()

df = pd.DataFrame(history["verdicts"])
df["timestamp"] = pd.to_datetime(df["timestamp"])
df["is_bullish"] = df["council_ruling"].isin(["BUY", "ACCUMULATE", "STRONG_BUY"])

# Analyze: what happened to BTC price after bullish signals?
bullish_signals = df[df["is_bullish"]]
print(f"Total bullish signals in 90 days: {len(bullish_signals)}")
print(f"Average confidence: {bullish_signals['council_confidence'].mean():.2%}")

council_mode: The Safety Check You Must Implement

Always check council_mode before acting on a verdict. When the value is "judiciary", the verdict was produced by the rule-based fallback system during an Anthropic API outage - not the full council (7 agents on BTC, 6 agents on other councils).

Fallback verdicts have materially lower reliability (~47% confidence vs ~76% for full council). AIOKA's Ghost Trader will not trade on them. Your application should handle this case:

verdict = requests.get(
    "https://api.aioka.io/v1/verdict/latest",
    headers=headers
).json()

if verdict.get("council_mode") == "judiciary":
    print("Council in fallback mode - skipping signal")
else:
    # Process full council verdict
    process_signal(verdict)

Getting Started

The AIOKA API is designed for developers who want institutional-grade crypto intelligence without building the intelligence layer themselves.

Start building →

*This article is for informational purposes only and does not constitute financial advice. Past performance does not guarantee future results. Always do your own research before making any investment decisions.*