Documentation

API reference, usage examples, and pricing for AI agents and human developers.

Quick Start

Add AlgoVault to Claude Desktop in under 30 seconds. Paste this into your claude_desktop_config.json:

{
  "mcpServers": {
    "crypto-quant-signal": {
      "command": "npx",
      "args": ["-y", "crypto-quant-signal-mcp"]
    }
  }
}

Then ask Claude:

"Get me a trade call for BTC on the 1h timeframe"

Free tier: all 716 assets, all 11 timeframes (1m–1d), 100 calls/month. No signup needed. Upgrade to Starter ($9.99/mo) or Pro for higher monthly limits and unlimited funding-arb results.

Your agent can also ask AlgoVault to teach itself how to use the tools — see Knowledge Tools below.

Testing with raw HTTP / curl

If you want to test your API key without an MCP client (Claude Desktop, Cursor, Claude Code), the MCP Streamable HTTP protocol requires a 3-step handshake before tools/call:

AV_KEY="av_live_..."   # paste your API key

# 1. initialize — captures session-id from response headers
SESSION_ID=$(curl -sS -i -X POST https://api.algovault.com/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AV_KEY" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"curl","version":"1.0"}},"id":1}' \
  | awk 'BEGIN{IGNORECASE=1} /^mcp-session-id:/ {gsub(/\r/,""); print $2; exit}')

# 2. notify "initialized" (required by MCP protocol)
curl -sS -X POST https://api.algovault.com/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AV_KEY" \
  -H "Accept: application/json, text/event-stream" \
  -H "mcp-session-id: $SESSION_ID" \
  -d '{"jsonrpc":"2.0","method":"notifications/initialized"}' >/dev/null

# 3. now call tools/call
curl -sS -X POST https://api.algovault.com/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $AV_KEY" \
  -H "Accept: application/json, text/event-stream" \
  -H "mcp-session-id: $SESSION_ID" \
  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"get_trade_call","arguments":{"coin":"SOL","timeframe":"5m","exchange":"BINANCE"}},"id":2}'

Most users won't need this — Claude Desktop / Cursor / Claude Code MCP clients handle the handshake automatically. Use this only for direct integration into a non-MCP system or for debugging.

get_trade_call (alias: get_trade_signal)

Returns a composite BUY/SELL/HOLD trade call with confidence percentage, regime context, and reasoning across 5 exchanges.

Parameters

Name Type Description
coinstringAsset symbol. BTC, ETH, TSLA, GOLD. Required
timeframestringCandle interval. 1m 3m 5m 15m 30m 1h 2h 4h 8h 12h 1d. Default: 15m
exchangestringExchange to query. BINANCE (default), HL, BYBIT, OKX, BITGET. Asset availability varies per venue — pass exchange explicitly to target a specific venue.
includeReasoningbooleanInclude human-readable reasoning. Default: true

Example Response

{
  "call": "BUY",
  "confidence": 78,
  "price": 84250.50,
  "indicators": {
    "funding_rate": 0.0001,
    "funding_24h_avg": 0.00008,
    "funding_state": "NORMAL",
    "oi_change_pct": 2.4,
    "volume_24h": 2381602633,
    "trend_persistence": "HIGH",
    "breakout_pending": "INACTIVE"
  },
  "regime": "TRENDING_UP",
  "reasoning": "Trending regime, upward bias. Funding pressure mild. Volatility neither expanding nor compressed. Trend persistence elevated; momentum structure. Strong conviction from aligned signals.",
  "timestamp": 1712764800,
  "coin": "BTC",
  "timeframe": "1h",
  "_algovault": {
    "version": "1.10.0",
    "tool": "get_trade_call",
    "compatible_with": ["crypto-quant-risk-mcp", "crypto-quant-backtest-mcp"]
  }
}

scan_funding_arb

Scans cross-venue funding rate differences between Hyperliquid, Binance, and Bybit. Returns top arbitrage opportunities ranked by annualized spread.

Parameters

Name Type Description
minSpreadBpsnumberMinimum spread in basis points to include. Default: 5
limitnumberMax results to return. Default: 10. Free tier: max 5

Example Response

{
  "opportunities": [
    {
      "coin": "ETH",
      "rates": {
        "HlPerp": 0.000125,
        "BinPerp": -0.000042,
        "BybitPerp": -0.000038
      },
      "bestArb": {
        "longVenue": "Binance",
        "shortVenue": "Hyperliquid",
        "spreadBps": 13.4,
        "annualizedPct": 117.3,
        "direction": "Long Binance / Short Hyperliquid"
      }
    }
  ],
  "scannedPairs": 245,
  "timestamp": 1712764800,
  "_algovault": {
    "version": "1.10.0",
    "tool": "scan_funding_arb",
    "compatible_with": ["crypto-quant-risk-mcp", "crypto-quant-execution-mcp"]
  }
}

get_market_regime

Classifies the current market regime for any asset across 5 exchanges. Returns one of four states: TRENDING_UP, TRENDING_DOWN, RANGING, or VOLATILE.

Parameters

Name Type Description
coinstringAsset symbol. Required
timeframestring1h 4h 1d. Default: 4h
exchangestringExchange to query. HL (default), BINANCE, BYBIT, OKX, BITGET. Asset availability varies per venue — pass exchange explicitly to target a specific venue.

Example Response

{
  "regime": "TRENDING_UP",
  "confidence": 85,
  "metrics": {
    "adx_interpretation": "Strong trend",
    "volatility_interpretation": "Normal",
    "price_structure": "HIGHER_HIGHS",
    "trend_strength": "STRONG",
    "cross_venue_funding_sentiment": "BULLISH_BIAS",
    "funding_divergence_note": "HL funding 3.2x above CEX avg — longs concentrated on HL"
  },
  "suggestion": "Strong uptrend detected. Favor long positions with trend-following strategies.",
  "timestamp": 1712764800,
  "coin": "BTC",
  "timeframe": "4h",
  "_algovault": {
    "version": "1.10.0",
    "tool": "get_market_regime",
    "compatible_with": ["crypto-quant-risk-mcp", "crypto-quant-backtest-mcp"]
  }
}

Knowledge Tools

Two MCP tools that let your AI agent learn how to use AlgoVault before calling the trading tools. Search the docs lexically; ask synthesized questions; never invent a parameter shape again.

What are knowledge tools

Most MCP-aware agents read tools/list once, then invent parameter shapes when calling tools. AlgoVault ships two meta-tools that let an agent self-serve documentation instead:

  • search_knowledge — BM25 lexical search over every tool description, response shape, integration tutorial, and code example.
  • chat_knowledge — natural-language answer with citations, grounded in the same bundle.

Both tools query a knowledge bundle auto-rebuilt within 30 seconds of every release — no stale answers.

Ask AlgoVault any question about its MCP tools, response shapes, integration patterns (LangChain / LlamaIndex / MAF / CrewAI), or code examples. Returns ranked snippets from the canonical knowledge bundle. Use this BEFORE attempting any tool call to confirm correct parameter usage and avoid hallucinating tool shapes. Fast (BM25 lexical search, no LLM call, no quota cost). For natural-language synthesized answers, use chat_knowledge instead.

Parameters

Name Type Description
querystringNatural-language search query (3–500 chars). Required
limitnumberMax ranked results (1–50). Default: 10

chat_knowledge

Ask AlgoVault a natural-language question — get a synthesized answer with citations, grounded in the canonical knowledge bundle (every MCP tool description, response shape, integration tutorial, and code example). Use this when you need an explanation, code pattern, or "how do I" answer. For raw ranked snippets without LLM synthesis, use search_knowledge (faster, no quota cost).

Parameters

Name Type Description
questionstringNatural-language question (5–500 chars). Required
modelstringOptional model override. claude-haiku-4-5-20251001 (default), claude-sonnet-4-6

When to use which

Use case Pick Why
Param lookup before tool callsearch_knowledgeFree, fast (no LLM call), returns the exact describe-text snippet.
"How do I integrate with X"search_knowledgeIntegration tutorials are indexed verbatim. BM25 ranks the right tutorial first.
Compare two toolschat_knowledgeSynthesis across multiple snippets needs an LLM. Cited answer beats raw retrieval.
"Write me code for X"chat_knowledgePattern synthesis from code examples needs reasoning. Free tier covers 10/month.

Worked examples

1. Discovery query — agent asks for trade-call docs before calling get_trade_call:

search_knowledge({
  query: "how do I get a trade call with stop loss for BTC"
})
// → ranked snippets including get_trade_call describe-text + integration excerpts

2. Comparison query — ask for synthesis across two tool descriptions:

chat_knowledge({
  question: "what's the difference between get_trade_call and get_market_regime"
})
// → synthesized answer with [source: ...] citations

3. Integration discovery — agent finds the LangChain tutorial:

search_knowledge({
  query: "how do I integrate with LangChain"
})
// → LangChain integration tutorial ranks first, with full code snippet

4. Direct HTTP — search:

curl -X POST https://api.algovault.com/api/search \
  -H "Content-Type: application/json" \
  -d '{"query":"BTC stop loss","limit":3}'

# → { "query": "BTC stop loss", "total_results": 3, "results": [...], "_algovault": {...} }

5. Direct HTTP — chat:

curl -X POST https://api.algovault.com/api/chat \
  -H "Content-Type: application/json" \
  -d '{"question":"how do I get a BTC trade call","model":"claude-haiku-4-5-20251001"}'

# → { "question": "...", "answer": "...", "citations": [...], "model": "...", "_algovault": {...} }

HTTP API

Both tools also expose plain HTTP endpoints for non-MCP consumers. No streamable-HTTP handshake required — just POST with JSON body.

Endpoint Body Cache
POST /api/search{"query": "string", "limit": 10}public, max-age=300
POST /api/chat{"question": "string", "model": "..."}no-store (per-user)

Error contract: INVALID_QUERY / QUERY_TOO_SHORT / QUERY_TOO_LONG / INVALID_QUESTION / QUESTION_TOO_SHORT / QUESTION_TOO_LONG / INVALID_MODEL / CHAT_QUOTA_EXHAUSTED / INTERNAL_ERROR. All return JSON {"code": "...", "message": "..."}.

Rate limits & cost

Tier search_knowledge chat_knowledge Notes
FreeUnlimited10 / monthSearch is BM25-only, no LLM cost.
StarterUnlimited50 / monthDefault model: claude-haiku-4-5-20251001.
ProUnlimited200 / monthAdds claude-sonnet-4-6 upgrade option.
EnterpriseUnlimited2000 / monthCustom limits available.

Cost transparency: chat_knowledge costs about $0.002 per call with prompt caching. Quota resets at the first of each UTC month.

Integration

Drop AlgoVault into any MCP-compatible client, any major agent framework, or any exchange Agent Trade Kit. Pick your path below.

Connect Your MCP Client

Your av_live_… API key works across every MCP-compatible client. Pick yours below. Free tier (no key) also works for every coin + every timeframe, capped at 100 calls/month.

Surface Setup What you get
Claude Desktop Settings → Connectors → Add custom connector, or edit claude_desktop_config.json Native Streamable-HTTP MCP. AlgoVault tools (get_trade_call, scan_funding_arb, get_market_regime) callable in any chat.
Cursor Edit ~/.cursor/mcp.json (global) or .cursor/mcp.json (project) IDE-native MCP. Cursor's coding agent pulls live signals while editing strategy code.
Cline (VSCode) Cline panel → MCP Servers → Remote Servers tab, or edit cline_mcp_settings.json VSCode-side coding agent with AlgoVault tools available.
Claude Code claude mcp add --transport http … --header … — or commit .mcp.json to repo root Per-project MCP. Useful for backtest / strategy-dev repos. Team-shared via .mcp.json.
Smithery npx -y @smithery/cli install crypto-quant-signal-mcp --client <name> Auto-managed connection via Smithery registry. Easiest install across clients.
Plain HTTP / curl curl -X POST https://api.algovault.com/mcp … Raw JSON-RPC. For developers integrating into bots, scripts, or non-MCP services.
Claude Desktop — setup walkthrough

Easiest path (UI): Open Claude Desktop → SettingsConnectorsAdd custom connector. Name it AlgoVault. URL: https://api.algovault.com/mcp. Add Authorization: Bearer av_live_… as a custom header (paid tier). Save and restart Claude Desktop.

JSON path: Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "algovault": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.algovault.com/mcp",
               "--header", "Authorization: Bearer ${AV_API_KEY}",
               "--header", "X-AlgoVault-Track-Token:chan-docs"]
    }
  }
}

Set AV_API_KEY in the env block or your shell. Free tier: drop the Authorization header, but keep the X-AlgoVault-Track-Token header.

Verify: ask Claude "Get me a trade call for BTC on the 1h timeframe". Tool indicator appears bottom-right of the input box.

Cursor — setup walkthrough

Edit ~/.cursor/mcp.json (global, all projects) or .cursor/mcp.json in the project root (per-project, commit-friendly):

{
  "mcpServers": {
    "algovault": {
      "url": "https://api.algovault.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:AV_API_KEY}",
        "X-AlgoVault-Track-Token": "chan-docs"
      }
    }
  }
}

Set AV_API_KEY in your shell. Restart Cursor. The Cursor agent now has AlgoVault tools available while editing strategy code.

Cline (VSCode) — setup walkthrough

Open the Cline panel in VSCode → MCP ServersRemote Servers tab → Add server. Or edit cline_mcp_settings.json (path varies by OS; access via Configure MCP Servers):

{
  "mcpServers": {
    "algovault": {
      "type": "streamableHttp",
      "url": "https://api.algovault.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:AV_API_KEY}",
        "X-AlgoVault-Track-Token": "chan-docs"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

type: "streamableHttp" is the modern transport (recommended). The legacy "sse" type still works but is being deprecated upstream.

Claude Code — setup walkthrough

One-liner (recommended):

claude mcp add --transport http --scope project algovault https://api.algovault.com/mcp \
  --header "Authorization: Bearer $AV_API_KEY" \
  --header "X-AlgoVault-Track-Token:chan-docs"

This writes a .mcp.json in your repo root which you can commit so every teammate gets the same MCP config:

{
  "mcpServers": {
    "algovault": {
      "type": "http",
      "url": "https://api.algovault.com/mcp",
      "headers": {
        "Authorization": "Bearer ${AV_API_KEY}",
        "X-AlgoVault-Track-Token": "chan-docs"
      }
    }
  }
}

Verify: in Claude Code, run /mcp to list connected servers; AlgoVault should appear with its 3 tools.

Smithery — setup walkthrough

The Smithery CLI installs and configures the MCP server in your client of choice automatically:

# Pick one — replace <client> with: claude, cursor, cline, claude-code
npx -y @smithery/cli install crypto-quant-signal-mcp --client <client>

The CLI writes the right config file for your client and prompts for any required env vars (like AV_API_KEY for paid-tier access). Easiest path if you're new to MCP. Browse the AlgoVault listing at smithery.ai.

Plain HTTP / curl — advanced testing

For non-MCP integrations (bots, scripts, services), call the JSON-RPC endpoint directly. Streamable-HTTP MCP requires a 3-step handshake: initializenotifications/initializedtools/call. See Testing with raw HTTP / curl for the full sequence.

One-shot smoke (free tier, no auth):

curl -sS https://api.algovault.com/health

Returns {"status":"ok","version":"1.10.3","stripe":true}.

Config formats verified 2026-04-30 against: MCP quickstart · Cursor MCP docs · Cline remote-server docs · Claude Code MCP docs · @smithery/cli on npm. Config formats can drift — if a snippet here doesn't work, please refer to the upstream doc and report it at GitHub issues.

Connect Your AI Agent

Building on a major agent framework? AlgoVault MCP plugs into 4 of them via the framework's canonical MCP-adapter library. Each pairing ships with a runnable Python demo.

Framework Setup What you get
LangChain pip install langchain-mcp-adapters · MultiServerMCPClient with streamable HTTP AlgoVault tools as LangChain BaseTool objects in any create_react_agent or LangGraph workflow.
LlamaIndex pip install llama-index-tools-mcp · BasicMCPClient + McpToolSpec AlgoVault tools as LlamaIndex FunctionTool objects in any FunctionAgent or ReActAgent.
Microsoft Agent Framework pip install agent-framework · MCPStreamableHTTPTool(url=…) AlgoVault tools called directly or handed to any ChatAgent in the MAF ecosystem.
CrewAI pip install crewai 'crewai-tools[mcp]' · MCPServerAdapter AlgoVault tools as CrewAI BaseTool objects in any Crew or single Agent workflow.
LangChain — setup walkthrough

Install the canonical bridge maintained by LangChain:

pip install langchain-mcp-adapters

Connect once, then call tools from any LangChain agent:

from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({"algovault": {
    "url": "https://api.algovault.com/mcp",
    "transport": "streamable_http"}})
tools = await client.get_tools()
verdict = await tools[0].ainvoke({"coin": "BTC", "timeframe": "4h"})

Full tutorial + runnable demo →

LlamaIndex — setup walkthrough

Install the canonical bridge maintained by LlamaIndex:

pip install llama-index-tools-mcp

Call directly via BasicMCPClient, or adapt all 4 tools to FunctionTool via McpToolSpec:

from llama_index.tools.mcp import BasicMCPClient

client = BasicMCPClient("https://api.algovault.com/mcp")
result = await client.call_tool(
    "get_trade_call", {"coin": "BTC", "timeframe": "4h"})

Full tutorial + runnable demo →

Microsoft Agent Framework — setup walkthrough

Install the framework (MCP support is built in):

pip install agent-framework

Open an MCP session, call tools directly, or hand the tool to a ChatAgent:

from agent_framework import MCPStreamableHTTPTool

tool = MCPStreamableHTTPTool(
    name="algovault",
    url="https://api.algovault.com/mcp",
    load_prompts=False)
async with tool:
    contents = await tool.call_tool(
        "get_trade_call", coin="BTC", timeframe="4h")

Note: load_prompts=False matters because AlgoVault MCP is tools-only.

Full tutorial + runnable demo →

CrewAI — setup walkthrough

Install CrewAI with the MCP extras (the canonical adapter):

pip install crewai 'crewai-tools[mcp]'

Open the adapter as a context manager; all 4 AlgoVault tools land as CrewAI BaseTool objects:

from crewai_tools import MCPServerAdapter

server_params = {"url": "https://api.algovault.com/mcp",
                 "transport": "streamable-http"}
with MCPServerAdapter(server_params) as tools:
    raw = tools[0].run(coin="BTC", timeframe="4h", exchange="BINANCE")

Full tutorial + runnable demo →

Tutorials verified 2026-05-18 against: langchain-mcp-adapters · llama-index-tools-mcp · agent-framework · crewAI-tools MCP. Snippets can drift — if one doesn't work, please refer to the upstream doc and report it at GitHub issues.

Try a framework integration: algovault.com/integrations/langchain

Connect Your Exchange Kit

Already running an exchange's Agent Trade Kit? Pair AlgoVault's composite verdict with the kit's execution layer. AlgoVault returns analytics; the exchange kit places orders; your agent decides.

Exchange Setup What you get
Binance claude plugin install binance/binance-skills-hub · Spot Testnet execution Composite verdict + official Binance Skills Hub. Agent fetches signals, decides, executes against Binance's testnet.
OKX npx -y @okx_ai/okx-trade-mcp · 83 execution tools (spot, swap, futures, options, grid) Composite verdict + OKX's full execution surface. Agent reads signals, places orders across spot or derivatives via one MCP server.
Bybit npx -y bybit-official-trading-server · Linear Perpetual + conditional orders Composite verdict + Bybit's official MCP server. Agent fetches AlgoVault signals, places perpetual + conditional orders via Bybit testnet.
Bitget npx -y bitget-mcp-server · GetClaw agent-native execution Composite verdict + Bitget's MCP server inside a dedicated AI account. Agent-native execution; isolate from your main funds.
Gemini node packages/mcp-server/dist/index.js · Self-hosted Node MCP (Apache-2.0), sandbox-gated Composite verdict + Gemini's Agentic Trading MCP. Agent reads signals, places sandbox orders via gemini_new_order; subaccounts isolate each agent.
Kraken kraken mcp -s all · Single Rust binary (MIT), 151 commands, keyless paper engine Composite verdict + the Kraken CLI's stdio MCP. Agent reads signals, simulates orders on the keyless paper engine before going live.
Alpaca uvx alpaca-mcp-server · Crypto toolsets, paper venue default-on Composite verdict + Alpaca's crypto MCP Server. Agent reads signals, places notional BTC/USD paper orders via place_crypto_order.
Binance — setup walkthrough

Install the Skills Hub plugin alongside AlgoVault:

claude plugin install AlgoVaultLabs/algovault-skills
claude plugin install binance/binance-skills-hub

Your agent now has AlgoVault's analytics tools and Binance's execution tools side-by-side. Set BINANCE_TESTNET=true for zero real-money risk during development.

Full tutorial + runnable demo →

OKX — setup walkthrough

Install OKX's official trade MCP server in your client config:

{
  "mcpServers": {
    "algovault": {"url": "https://api.algovault.com/mcp"},
    "okx-trade": {"command": "npx", "args": ["-y", "@okx_ai/okx-trade-mcp"]}
  }
}

Set OKX_DEMO=true (or pass --demo) for the demo trading environment. Real keys go in env vars; never commit them.

Full tutorial + runnable demo →

Bybit — setup walkthrough

Wire Bybit's official server next to AlgoVault:

{
  "mcpServers": {
    "algovault": {"url": "https://api.algovault.com/mcp"},
    "bybit-trade": {"command": "npx", "args": ["-y", "bybit-official-trading-server"]}
  }
}

Set BYBIT_TESTNET=true + API keys in env. Conditional orders (stop-loss, take-profit, OCO) are first-class — your agent can attach risk policy at order time.

Full tutorial + runnable demo →

Bitget — setup walkthrough

Bitget exposes a dedicated AI sub-account ("GetClaw") for agent execution:

{
  "mcpServers": {
    "algovault": {"url": "https://api.algovault.com/mcp"},
    "bitget-trade": {"command": "npx", "args": ["-y", "bitget-mcp-server"]}
  }
}

Set BITGET_DEMO=true in the wrapper (the MCP server has no built-in demo flag — the env var gates order placement at the client level). Fund the GetClaw account separately from your main account.

Full tutorial + runnable demo →

Gemini — setup walkthrough

Build Gemini's self-hosted MCP from source, alongside AlgoVault:

git clone https://github.com/gemini/developer-platform
cd developer-platform/packages/mcp-server
npm install
npm run build

Set GEMINI_API_BASE_URL=https://api.sandbox.gemini.com/v1 for zero real-money risk during development. Public market-data tools need no keys.

Full tutorial + runnable demo →

Kraken — setup walkthrough

Install the Kraken CLI (one binary), then serve it over MCP next to AlgoVault:

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/krakenfx/kraken-cli/releases/latest/download/kraken-cli-installer.sh | sh
kraken mcp -s all

The kraken paper engine needs no keys and no account. Run --validate before any live order; arm cancel-after as a dead-man's switch.

Full tutorial + runnable demo →

Alpaca — setup walkthrough

Run Alpaca's crypto MCP Server zero-install, scoped to crypto toolsets, alongside AlgoVault:

{
  "mcpServers": {
    "algovault": {"url": "https://api.algovault.com/mcp"},
    "alpaca": {"command": "uvx", "args": ["alpaca-mcp-server"]}
  }
}

Set ALPACA_TOOLSETS=trading,crypto-data to scope crypto-only; ALPACA_PAPER_TRADE defaults to true for zero real-money risk.

Full tutorial + runnable demo →

Tutorials verified 2026-05-19 against: Binance Skills Hub · @okx_ai/okx-trade-mcp · bybit-official-trading-server · bitget-mcp-server. Snippets can drift — if one doesn't work, please refer to the upstream doc and report it at GitHub issues.

Try an exchange integration: algovault.com/integrations/binance

On-Chain Verification

Every call is hashed and anchored on Base L2 via daily Merkle batches. This makes the track record tamper-proof.

How It Works

1

Every BUY/SELL call is hashed using keccak256(coin, signal, confidence, timeframe, timestamp, price) at the moment it's generated

2

Hashes accumulate throughout the day

3

At 00:05 UTC, all new hashes are assembled into a Merkle tree

4

The Merkle root is published to the MerkleRootRegistry smart contract on Base L2

5

Anyone can verify that a specific call existed in a batch by checking its Merkle proof against the on-chain root

Verification Endpoints

GET /api/verify-signal?signalId=<ID>

Returns: call details, hash, Merkle proof, batch info, Basescan tx link, and a boolean verified field.

GET /api/merkle-batches

Returns: list of all published batches with root hashes, call counts, tx hashes, and Basescan links.

Visual Verification

Visit algovault.com/verify to look up any call and see its on-chain proof in a human-readable format.

Contract Details

Address0x6485396ac981fe0a58540dfbf3e730f6f7bcbf81
ChainBase (chain ID 8453)
ExplorerView on Basescan →

What This Proves

  • Calls were recorded BEFORE outcomes were known
  • No call can be retroactively edited or deleted
  • The complete set of calls in each batch is locked — cherry-picking is detectable via sequential call IDs

Skills & Usage Examples

20 real-world workflows for AI agents and human developers. From simple one-liners to multi-agent orchestration.

01

Quick BTC Check

Beginner

The simplest possible call. Ask your agent for a single trade call.

"Get me a trade call for BTC on the 1h timeframe"
Tools: get_trade_call
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
02

Portfolio Scanner

Intermediate

Loop through the top 10 assets, get trade calls for each, and filter by high confidence.

"Get trade calls for BTC, ETH, SOL, DOGE, XRP, ADA, AVAX, LINK, DOT, and MATIC on the 15m timeframe. Only show me the ones with confidence above 70%."
Tools: get_trade_call × 10  |  Pattern: batch calling, confidence filtering
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
03

Regime-Aware Trading

Intermediate

Check the market regime first. Only request trade calls when the regime is favorable for directional trading.

"First check the market regime for ETH on the 4h timeframe. If it's TRENDING_UP or TRENDING_DOWN, get me a trade call on the 15m timeframe. If it's RANGING or VOLATILE, skip it."
Tools: get_market_regimeget_trade_call  |  Pattern: conditional chaining
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
04

Funding Arb Monitor

Intermediate

Scan for cross-venue funding rate arbitrage opportunities. Alert when the annualized spread exceeds your threshold.

"Scan for funding arbitrage opportunities with a minimum spread of 10 basis points. Show me the top 5 ranked by annualized return."
Tools: scan_funding_arb  |  Pattern: threshold-based alerting
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
05

Full 3-Tool Pipeline

Advanced

The complete AlgoVault workflow: regime detection, trade call, then arb check for the same asset. Maximum context for one decision.

"For SOL: first get the market regime on 4h, then get a trade call on 15m, then check if there are any funding arb opportunities. Give me a combined recommendation based on all three."
Tools: get_market_regimeget_trade_callscan_funding_arb  |  Pattern: full pipeline composition
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
06

Multi-Timeframe Confirmation

Advanced

Get trade calls on multiple timeframes for the same asset. Only act when all timeframes agree on direction.

"Get trade calls for ETH on the 5m, 15m, and 1h timeframes. Only tell me to trade if all three agree on the same direction (all BUY or all SELL)."
Tools: get_trade_call × 3  |  Pattern: multi-timeframe consensus
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
07

TradFi Rotation

Advanced

Compare regime and direction across TradFi perpetuals. Rotate into the asset with the strongest trend.

"Get the market regime and trade call for TSLA, GOLD, and SP500 on the 4h timeframe. Which one has the strongest trend with the highest confidence trade call? Recommend the best one to trade."
Tools: get_market_regime × 3 + get_trade_call × 3  |  Pattern: cross-asset comparison
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
08

Risk-Gated Entry

Advanced

Only enter trades when both confidence and regime alignment pass your risk filters. Skip everything else.

"Check BTC regime on 4h, then get a trade call on 15m. Only recommend entry if confidence is 75% or higher AND the regime is TRENDING (not VOLATILE or RANGING). Otherwise say 'no trade'."
Tools: get_market_regimeget_trade_call  |  Pattern: dual risk filter
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
09

Funding Sentiment Dashboard

Advanced

Get market regime for major assets and use the cross-venue funding sentiment to gauge overall market bias.

"Get the market regime for BTC, ETH, and SOL on the 4h timeframe. Summarize the cross-venue funding sentiment for each. Is the overall market leaning bullish or bearish based on where funding is concentrated?"
Tools: get_market_regime × 3  |  Pattern: macro sentiment aggregation
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
10

Contrarian Meme Scanner

Advanced

Scan lower-tier assets for contrarian setups: high-confidence SELL calls during an uptrend may signal crowded longs about to unwind.

"Get the market regime for DOGE, SHIB, PEPE, WIF, and BONK on 4h. For any that are TRENDING_UP, get a trade call on 15m. Flag any that return SELL with confidence above 70% — those might be crowded longs ready to unwind."
Tools: get_market_regime × 5 + get_trade_call (conditional)  |  Pattern: contrarian divergence detection
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
11

Divergence Detector

Advanced

Compare trade call direction vs market regime. When they disagree, flag it as a high-risk divergence.

"For BTC and ETH: get the market regime on 4h and a trade call on 15m. If the trade call says BUY but the regime is TRENDING_DOWN (or vice versa), flag it as a divergence with a risk warning."
Tools: get_market_regime + get_trade_call per asset  |  Pattern: signal-regime divergence
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
12

Hourly Digest Bot

Advanced

Build an automated digest: scan all tier-1 and tier-2 assets every hour, summarize trade calls and market regime into a brief report.

"Scan BTC, ETH, SOL, AVAX, LINK, DOGE, XRP, ADA for trade calls on 1h. Also get the market regime for BTC and ETH on 4h. Summarize as a brief market digest: how many BUYs vs SELLs, overall regime, and top 3 highest-confidence calls."
Tools: get_trade_call × 8 + get_market_regime × 2  |  Pattern: periodic digest, notification-ready
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
13

Hedging Advisor

Advanced

You hold a long ETH position. Check regime and trade call — if both turn bearish, look for a funding arb to hedge via the cheaper venue.

"I'm currently long ETH. Get the market regime on 4h and a trade call on 1h. If both are bearish, scan funding arb for ETH and tell me which venue has the cheapest short to hedge my position."
Tools: get_market_regimeget_trade_callscan_funding_arb  |  Pattern: defensive hedging
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
14

Volatility Breakout Watch

Advanced

Use regime detection as a screener: find assets in VOLATILE regime with high confidence — these are breakout candidates. Then get trade call for direction.

"Check the market regime for BTC, ETH, SOL, AVAX, LINK, and DOGE on 4h. For any in VOLATILE regime with confidence above 70%, get a trade call on 5m. Those are potential breakout trades."
Tools: get_market_regime × 6 + get_trade_call (conditional)  |  Pattern: regime as screener
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
15

Cross-Asset Correlation

Advanced

Get trade calls for BTC, ETH, SOL simultaneously. If all say SELL, it's a macro risk-off signal, not just one asset.

"Get trade calls for BTC, ETH, and SOL on the 1h timeframe. If all three say the same direction, flag it as a market-wide move. If they disagree, note which ones are diverging."
Tools: get_trade_call × 3  |  Pattern: correlation / macro signal
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
16

Funding Cash-and-Carry

Advanced

Find a funding arb spread, then get a trade call on the long side. If the trade call agrees with the long direction, you have double conviction.

"Scan funding arb with minimum 10 bps spread. For the top opportunity, get a trade call for the asset on 15m. If the trade call agrees with the long side of the arb, flag it as a high-conviction cash-and-carry setup."
Tools: scan_funding_arbget_trade_call  |  Pattern: arb + directional alignment
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
17

Weekend vs Weekday Patterns

Research

Schedule trade calls every 4 hours, log results over time. Compare weekend vs weekday regime patterns to find exploitable edges.

"Every 4 hours, get a trade call for BTC on 4h and log the regime, direction, and confidence. After a week, compare weekend vs weekday patterns. Are weekends more RANGING? Do SELL calls cluster on Sundays?"
Tools: get_trade_call + get_market_regime (scheduled)  |  Pattern: data collection, research
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
18

Agent Portfolio Rebalance

Advanced

Daily regime check for each asset in your portfolio. Shift allocation toward TRENDING assets, reduce exposure to VOLATILE/RANGING positions.

"My portfolio holds BTC, ETH, SOL, AVAX, and LINK. Get the market regime for each on the 1d timeframe. Recommend which ones to overweight (TRENDING) and which to underweight (VOLATILE or RANGING)."
Tools: get_market_regime × 5  |  Pattern: regime-based portfolio allocation
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
19

Smart DCA Bot

Advanced

Dollar-cost averaging, enhanced: skip buys when the trade call says SELL with high confidence. Only DCA when direction is neutral or favorable.

"I DCA into BTC every day. Before today's buy, get a trade call on the 4h timeframe. If it says SELL with confidence above 70%, skip today's buy and wait. Otherwise proceed normally."
Tools: get_trade_call  |  Pattern: strategy enhancement, DCA optimization
claude plugin install AlgoVaultLabs/algovault-skills View Skill →
20

Multi-Agent War Room

Expert

Three specialized agents, one coordinator. Agent A handles regime detection, Agent B runs trade calls, Agent C monitors funding arbs. The coordinator synthesizes all three into a single decision.

"Set up three agents: Agent A gets market regime for BTC, ETH, SOL on 4h. Agent B gets trade calls for the same assets on 15m. Agent C scans funding arb for spreads above 8 bps. Combine all results into a single dashboard showing: regime, direction, confidence, and best arb for each asset."
Tools: All 3 tools in parallel  |  Pattern: multi-agent orchestration
claude plugin install AlgoVaultLabs/algovault-skills View Skill →

Pricing & Limits

Two payment rails: Stripe subscriptions for human developers, x402 micropayments (USDC on Base) for autonomous agents.

Subscription Tiers

Free Starter Pro Enterprise
Price$0$9.99/mo$49/mo$299/mo
Monthly calls1003,00015,000100,000
AssetsBTC + ETHAll crypto + TradFiAll crypto + TradFiAll crypto + TradFi
Timeframes15m, 1hAll 11All 11All 11
Funding arb resultsTop 5UnlimitedUnlimitedUnlimited

Free HOLD Policy

When the engine evaluates an asset and determines "don't trade" (HOLD), the call is free:

  • No x402 charge
  • No deduction from subscription quota
  • Rate limiting still applies (prevents abuse)
  • Only BUY and SELL verdicts are charged

This aligns incentives: you only pay when we see a tradeable opportunity. Current HOLD rate is ~84%, meaning the engine rejects most scans.

What happens after you subscribe

  1. Click "Subscribe to [Plan]" — on /signup. We redirect you to Stripe Checkout (we never see your card).
  2. Pay on Stripe — Stripe sends you a receipt email. Behind the scenes, our webhook generates a unique API key for your subscription tier.
  3. Land on the Welcome page — Your API key is shown in green — copy it. We also email it to your billing address (check spam, sender: [email protected]).
  4. Make your first call curl -H "Authorization: Bearer av_live_…" https://api.algovault.com/mcp … or paste the key into your Claude Desktop / Cursor / Claude Code MCP config. Need to find your key later? Visit /account.

x402 Pay-Per-Call (USDC on Base)

No signup. No API key. Your agent pays per call with USDC on Base. Works with any x402-compatible wallet.

Tool Price
get_trade_call$0.02 (HFT timeframes: up to $0.05)
scan_funding_arb$0.01
get_market_regime$0.02

FAQ

How often should I call get_trade_call?
Match your call frequency to the timeframe. A 5m trade call is stale after ~5 minutes, while a 4h call is relevant for several hours. For most agents, calling once per candle close on your chosen timeframe is optimal.
Can I combine multiple tools in one workflow?
Yes — and it's encouraged. The recommended flow is: regime → trade call → arb. Check the regime first to decide if conditions favor directional trading, then get a trade call for direction, then check if a funding arb exists on the same asset. See the usage examples for 20 real-world workflows.
What's the latency per call?
Typically 1–3 seconds. Each call fetches live data from the chosen exchange — Binance (default for get_trade_call), Hyperliquid (default for get_market_regime), Bybit, OKX, or Bitget. Funding arb scans Hyperliquid, Binance, and Bybit. Response time depends on the exchange's API latency and the number of assets scanned.
How is trade call performance tracked?
Every trade call with confidence ≥ 60% is automatically recorded. After enough candles have passed, the system measures PFE (Peak Favorable Excursion) win rate — did price move in the called direction at any point during the evaluation window? Results are available via the performance://signal-performance MCP resource and on the live dashboard.
What assets are supported?
All perpetuals listed across 5 exchanges — Binance, Hyperliquid, Bybit, OKX, and Bitget. This includes standard crypto perps (BTC, ETH, SOL, etc.) and liquidity-filtered meme coins on every venue. TradFi perpetuals (TSLA, XAU, NVDA, SPX, MSTR, COIN, AAPL, and more) are available on multiple venues — asset availability varies per venue; pass exchange explicitly to target a specific venue. Low-liquidity meme coins are automatically gated to prevent unreliable trade calls.
Do you provide exit calls?
No. AlgoVault provides directional entry calls only — BUY, SELL, or HOLD. Your agent or strategy determines exit timing. This is by design: exit logic depends on your risk tolerance, position size, and portfolio context, which only you know. PFE Win Rate measures whether the called direction was correct, independent of exit.
What is x402 and how do agent payments work?
x402 is an open protocol for machine-to-machine micropayments. Your agent pays per API call with USDC on Base — no signup, no API key, no subscription. The agent signs an ERC-3009 authorization, the server verifies it on-chain, and the call proceeds. It's the native payment rail for autonomous agents that don't have credit cards.
What is the HOLD Rate?
HOLD Rate is the percentage of scans where the engine declines to issue a BUY or SELL call. A high HOLD rate (~84%) means the engine is selective — it only calls when multiple indicators align. HOLD calls are always free across all tiers.
How do I verify a call's integrity?
Every call is hashed and anchored on Base L2 via daily Merkle batches. Visit algovault.com/verify to look up any call by ID. You'll see its hash, Merkle proof, batch details, and a direct link to the transaction on Basescan. You can also call the API directly: GET /api/verify-signal?signalId=<ID>.
Can I run AlgoVault locally?
Yes. Install via npx -y crypto-quant-signal-mcp and it runs locally in stdio mode for Claude Desktop. For remote access, the hosted version at api.algovault.com/mcp supports Streamable HTTP transport.

Built by AlgoVault Labs