MadeOnSolMade on Sol

Data APIs

Solana Data APIRobinhood Chain API

Intelligence

Telegram AlertsKOL TrackerWallet ScannerToken LookupDeployer Hunter
Trading BotsTrading TerminalsWallet TrackingToken Scanners
View all solutions
Optimization guidesAPI DocsWebSocket StreamingMCP & SDKsx402 for AI AgentsAgent Intelligence Gateway
Discover ToolsCompare ToolsSubmit a ToolAdvertiseBlog
Pricing
Get real-time feedsSign in
MadeOnSolMade on Sol

Solana and Robinhood Chain intelligence — KOL wallet tracking, deployer intelligence, all-DEX trade streams, and a developer API. Discover, compare, and build.

Product

  • Solana Data API
  • Solana Wallet Checker
  • Robinhood Chain Wallet Checker
  • Robinhood Chain API
  • Robinhood Chain x402
  • MCP Servers & SDKs
  • x402 for AI Agents
  • Agent Intelligence Gateway
  • Pricing
  • Enterprise / For Businesses

Solutions

  • Trading Bots
  • Wallet Tracking
  • Copy Trading
  • Token Scanners
  • Trading Terminals
  • DEX Data
  • Smart Money
  • Token Risk
  • AI Agents
  • ShredPrism Stream
  • View all solutions

Developers

  • Optimization guides
  • API Docs
  • WebSocket Streaming
  • Changelog
  • API Status
  • Latency Benchmarks
  • Data Integrity
  • Data Dictionary
  • Methodology

Resources

  • All Tools
  • Compare Tools
  • Best Trading Bots
  • Best DEXs
  • Best Wallets
  • Best Analytics
  • Best DeFi
  • Best Snipers
  • Blog
  • Blog Archive
  • Signal Scorecard
  • Tool Uptime
  • Community
  • Submit a Tool
  • Advertise

Company

  • About
  • Contact
  • Security
  • Privacy
  • Terms
  • DPA
  • Disclaimer

© 2026 MadeOnSol

MadeOnSol — eenmanszaak, Hulshout, Belgium · KBO/BTW BE 1039.535.538 (art. 56bis, no VAT charged)

Runs on our own dedicated EU servers — self-hosted data stack, own Robinhood Chain node · security

Powered by:constant·k — Private Solana RPC Services
Optimization guidesValidate a KOL feed before increasing request volumeProcess webhook retries without duplicate effectsRecover a WebSocket feed after a disconnectReduce REST polling in a trading terminalMerge live candles with historical OHLCVCache KOL rankings while streaming tradesBudget REST calls and WebSocket slotsAPI reference
Optimization guidesProcess webhook retries without duplicate effects

Pro and above · Compare plans and subscribe

Process webhook retries without duplicate effects

Verify MadeOnSol webhook signatures and acknowledge deliveries after durable storage so retries do not duplicate alerts.

Integration choice

Choose a unique key for each effect. Write the event and its deduplication key atomically before returning success. Make downstream work retryable if the receiver restarts after acknowledgement.

Implementation stepsCode examplesVerify your integration

Implementation steps

  1. Register your HTTPS endpoint and select an event in the webhook settings. Save the signing secret on your server.
  2. Capture the original body bytes before JSON middleware runs. Pass them, the timestamp header, the signature header and your literal signing secret to the verifier below. Its five-minute freshness window is a receiver policy.
  3. After verification, validate the payload and persist it to a durable queue before acknowledging. Where a delivery ID is supplied, store it with the queued event under a unique constraint. For other events, choose a stable event-specific identity before performing repeat-sensitive work.
  4. Send a sample with POST /api/v1/webhooks/test using your API key and a JSON body containing the numeric webhook_id. Check success and status_code in the response. In your own receiver tests, alter one body byte and submit the same valid delivery twice. Expect rejection for the altered body and one application effect for the repeated delivery.

Code examples

Node.js signature verifier

import crypto from "node:crypto";

// rawBody:   the exact request bytes (never re-serialized JSON)
// secret:    the webhook secret exactly as the API returned it (do not hex-decode)
function verifyMadeOnSol(rawBody, timestamp, signature, secret) {
  // X-MadeOnSol-Timestamp: unix milliseconds, fresh on every retry
  if (typeof timestamp !== "string" || !/^\d{1,16}$/.test(timestamp)) return false;
  // Replay window: your choice, the server does not enforce one
  if (Math.abs(Date.now() - Number(timestamp)) > 5 * 60_000) return false;
  // X-MadeOnSol-Signature: 64 hex characters, bare (no algorithm prefix)
  if (typeof signature !== "string" || !/^[0-9a-f]{64}$/i.test(signature)) return false;
  const expected = crypto
    .createHmac("sha256", secret)
    .update(`${timestamp}.`)
    .update(rawBody)
    .digest();
  // Both sides are exactly 32 bytes here, so this compares in constant time and cannot throw
  return crypto.timingSafeEqual(expected, Buffer.from(signature, "hex"));
}

Verify your integration

Deliver one signed event twice and stop the worker after the first queue write. On restart, the event should still be available and the application should produce one alert. Altering the signed bytes should prevent a queue write.

Read this guide as Markdown
Webhook setupWebhook payloads