Agentic Signal API

Pricing

$0.02 per call to paid endpoints (/signal/*).

Paywall (x402)

Paid responses are protected with the x402 scheme on Base (eip155:8453) using USDC.

• payTo: 0x911ce72BBFa731324D9Bc57F61525e1b230f4E6B
• scheme: x402 (exact)

Sentiment caching

Sentiment is computed via xAI (Grok) and cached per-asset on a ~24h cadence. Signal endpoints never block on sentiment refresh.

• sentimentMeta.status is one of: fresh, stale, refreshing, missing, error.
• When refreshing/missing, the API returns immediately with the last cached score (or 0) and refreshes in the background.

x402 payment (Node)

Paid endpoints return 402 Payment Required. Use an x402-capable client to pay, then retry the same request.

// pseudo-code: wire in your preferred x402 SDK
import fetch from "node-fetch";

const url = "https://signal.agenticsignal.dev/signal/btc";

// 1) initial request (expect 402)
let res = await fetch(url);
if (res.status !== 402) throw new Error("expected 402, got " + res.status);
const quote = await res.json(); // or parse PAYMENT-REQUIRED header if provided

// 2) pay quote (USDC on Base) using x402 SDK / wallet
await payWithX402(quote);

// 3) retry same request
res = await fetch(url);
const signal = await res.json();
console.log(signal);

Tip: keep your retry idempotent (store asset+ts) and respect TTL/multiplier fields.

Install (OpenClaw skill)

curl -L -o agentic-signal.skill https://signal.agenticsignal.dev/agentic-signal.skill
openclaw skills install ./agentic-signal.skill

Alternative (GitHub release): download

Demo repo

git clone https://github.com/alphagrit/agentic-signal-demo-agent
cd agentic-signal-demo-agent/node
npm install
node index.mjs BTC

This demo is intentionally no-pay. Paid endpoints return 402 Payment Required unless you implement x402 payment.

GitHub

• Demo repo (Node + Python)
• Skill releases (agentic-signal.skill)

Proof (backtests)

• /proof?days=90
• /proof?days=180
• /proof?days=365

Endpoints

• GET /healthz — health check
• GET /signal/eth — paid ETH signal
• GET /signal/btc — paid BTC signal
• GET /verify — fetch public key for response signature verification

Example response (paid)

{
  "asset": "ETH",
  "ts": "2026-01-01T00:00:00.000Z",
  "coinbase": { "productId": "ETH-USD", "spotPriceUsd": 3456.78, "spotTime": "..." },
  "features": {
    "trend": "up",
    "regime": "risk_on",
    "sentimentScore": 0.2
  },
  "signal": { "action": "buy", "score": 0.63 }
}

Fields may evolve; rely on signal.action + signal.score as primary outputs.

Response signatures

Successful 200 responses from /signal/* include tamper-evident headers:

• X-Signal-Key-Id
• X-Signal-Signed-At
• X-Signal-Body-Sha256
• X-Signal-Signature (base64 Ed25519 signature)

Fetch the public key from /verify:

curl -s https://signal.agenticsignal.dev/verify

Canonical message (exactly, including newlines):

agentic-signal:v1
keyId:...
signedAt:...
method:GET
path:/signal/eth
bodySha256:...

Where bodySha256 is the hex SHA-256 of the raw response body (UTF-8 bytes).

Verify in Node.js

import crypto from "node:crypto";

const baseUrl = "https://signal.agenticsignal.dev";
const r = await fetch(baseUrl + "/signal/eth", { /* pay via x402 */ });
const bodyText = await r.text();

const keyId = r.headers.get("x-signal-key-id");
const signedAt = r.headers.get("x-signal-signed-at");
const bodySha256 = r.headers.get("x-signal-body-sha256");
const sigB64 = r.headers.get("x-signal-signature");

const v = await fetch(baseUrl + "/verify").then(x => x.json());
const publicKeyPem = v.publicKey;

const canonical = [
  "agentic-signal:v1",
  "keyId:" + keyId,
  "signedAt:" + signedAt,
  "method:GET",
  "path:/signal/eth",
  "bodySha256:" + bodySha256
].join("
");

const ok = crypto.verify(
  null,
  Buffer.from(canonical, "utf8"),
  crypto.createPublicKey(publicKeyPem),
  Buffer.from(sigB64, "base64")
);

console.log({ ok });

How to pay (Node.js / TypeScript)

Uses the x402 SDK (recommended). Works with public hosts (unlike awal x402 pay which may block private/internal hosts).

// npm i @x402/fetch @x402/evm viem

import { wrapFetchWithPayment } from "@x402/fetch";
import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

const RESOURCE_SERVER_URL = "https://signal.agenticsignal.dev";
	const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`;

const account = privateKeyToAccount(PRIVATE_KEY);
const walletClient = createWalletClient({
  account,
  chain: base,
  transport: http(),
});

const fetchWithPayment = wrapFetchWithPayment(fetch, walletClient);

	const res = await fetchWithPayment(RESOURCE_SERVER_URL + "/signal/eth");
console.log(await res.json());

cURL (unauthenticated)

curl -i https://signal.agenticsignal.dev/signal/eth

Expect 402 Payment Required + x402 payment requirements.