Chain Sentinel API

Scan a token in 5 seconds — no API key needed for free tier.

curl -X POST https://chainshieldsentinel.tech/api/scan \
  -H "Content-Type: application/json" \
  -d '{"address": "0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82", "chain": "bsc"}'

{
  "detail": "Rate limit exceeded. Try again in 45s. (20 scans/min limit)"
}

{
  "address": "0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82",
  "chain": "bsc",
  "name": "PancakeSwap Token",
  "symbol": "CAKE",
  "safety_score": 85,
  "risk_level": "safe",
  "is_honeypot": false,
  "can_sell": true,
  "buy_tax": 0.0,
  "sell_tax": 0.0,
  "owner_renounced": true,
  "owner_address": "0x0000000000000000000000000000000000000000",
  "is_verified": true,
  "is_proxy": false,
  "liquidity_locked": true,
  "lock_platform": "PancakeSwap",
  "price_usd": 2.45,
  "volume_24h": 52000000,
  "market_cap": 720000000,
  "holders": 1250000,
  "data_sources": ["GoPlus", "DexScreener"],
  "warnings": [],
  "positives": [
    "Contract source code is verified",
    "Ownership is renounced",
    "Liquidity is locked",
    "No honeypot patterns detected"
  ]
}

🐍 Python

import requests

API_URL = "https://chainshieldsentinel.tech/api/scan"
API_KEY = "cs_your_api_key_here"  # Optional for free tier

def scan_token(address: str, chain: str = "bsc") -> dict:
    """Scan a token for safety indicators."""
    headers = {"Content-Type": "application/json"}
    if API_KEY:
        headers["X-API-Key"] = API_KEY
    
    response = requests.post(API_URL, json={
        "address": address,
        "chain": chain
    }, headers=headers)
    
    response.raise_for_status()
    return response.json()


# Example: Scan CAKE on BSC
result = scan_token("0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82")

print(f"Token: {result['name']} ({result['symbol']})")
print(f"Safety Score: {result['safety_score']}/100")
print(f"Risk Level: {result['risk_level']}")
print(f"Honeypot: {result['is_honeypot']}")
print(f"Buy Tax: {result['buy_tax']}%")
print(f"Sell Tax: {result['sell_tax']}%")

⚡ JavaScript / Node.js

const API_URL = "https://chainshieldsentinel.tech/api/scan";
const API_KEY = "cs_your_api_key_here"; // Optional for free tier

async function scanToken(address, chain = "bsc") {
  const headers = { "Content-Type": "application/json" };
  if (API_KEY) headers["X-API-Key"] = API_KEY;

  const response = await fetch(API_URL, {
    method: "POST",
    headers,
    body: JSON.stringify({ address, chain })
  });

  if (!response.ok) {
    throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  }

  return response.json();
}

// Example: Scan CAKE on BSC
scanToken("0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82")
  .then(result => {
    console.log(`Token: ${result.name} (${result.symbol})`);
    console.log(`Safety Score: ${result.safety_score}/100`);
    console.log(`Risk Level: ${result.risk_level}`);
  })
  .catch(console.error);

🔧 cURL

# Free tier (no API key)
curl -s -X POST https://chainshieldsentinel.tech/api/scan \
  -H "Content-Type: application/json" \
  -d '{"address": "0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82", "chain": "bsc"}' \
  | jq '.'

# With API key
curl -s -X POST https://chainshieldsentinel.tech/api/scan \
  -H "Content-Type: application/json" \
  -H "X-API-Key: cs_your_api_key_here" \
  -d '{"address": "0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82", "chain": "bsc"}' \
  | jq '.safety_score, .risk_level, .is_honeypot'

🤖 Trading Bot Integration

Example: Auto-check tokens before buying in a trading bot.

import requests

def is_safe_to_buy(token_address: str, chain: str = "bsc",
                   min_score: int = 60, max_tax: float = 10.0) -> dict:
    """
    Check if a token is safe to buy.
    Returns dict with 'safe' (bool) and 'reason' (str).
    """
    try:
        result = requests.post(
            "https://chainshieldsentinel.tech/api/scan",
            json={"address": token_address, "chain": chain},
            headers={"X-API-Key": "cs_your_key"},
            timeout=10
        ).json()
        
        # Check honeypot
        if result.get("is_honeypot"):
            return {"safe": False, "reason": "Honeypot detected — cannot sell"}
        
        # Check safety score
        if result["safety_score"] < min_score:
            return {"safe": False, "reason": f"Score {result['safety_score']} < {min_score}"}
        
        # Check tax
        if result["buy_tax"] > max_tax:
            return {"safe": False, "reason": f"Buy tax {result['buy_tax']}% > {max_tax}%"}
        
        if result["sell_tax"] > max_tax:
            return {"safe": False, "reason": f"Sell tax {result['sell_tax']}% > {max_tax}%"}
        
        return {"safe": True, "reason": f"Score {result['safety_score']} — {result['risk_level']}"}
    
    except Exception as e:
        return {"safe": False, "reason": f"Scan failed: {e}"}


# Usage in your trading bot
check = is_safe_to_buy("0xNewTokenAddress...")
if check["safe"]:
    print(f"✅ Safe to buy: {check['reason']}")
    # execute_buy(token_address)
else:
    print(f"❌ Skipping: {check['reason']}")

import hmac
import hashlib

def verify_webhook(payload: bytes, signature: str, secret: str) -> bool:
    """Verify a Chain Sentinel webhook signature."""
    expected = hmac.new(
        secret.encode("utf-8"),
        payload,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(f"sha256={expected}", signature)

# In your webhook handler:
@app.post("/webhooks/chain-sentinel")
async def handle_webhook(request: Request):
    body = await request.body()
    signature = request.headers.get("X-ChainSentinel-Signature", "")
    event = request.headers.get("X-ChainSentinel-Event", "")
    
    if not verify_webhook(body, signature, "whsec_your_secret"):
        raise HTTPException(status_code=401, detail="Invalid signature")
    
    data = json.loads(body)
    
    if event == "scan.honeypot":
        # Alert: honeypot detected!
        print(f"🚨 Honeypot: {data['data']['name']}")
    elif event == "scan.complete":
        print(f"✅ Scan complete: {data['data']['safety_score']}/100")
    
    return {"status": "ok"}

const crypto = require("crypto");

function verifyWebhook(body, signature, secret) {
  const expected = crypto
    .createHmac("sha256", secret)
    .update(body)
    .digest("hex");
  return signature === `sha256=${expected}`;
}

// Express.js handler
app.post("/webhooks/chain-sentinel", (req, res) => {
  const signature = req.headers["x-chainsentinel-signature"];
  const event = req.headers["x-chainsentinel-event"];
  
  if (!verifyWebhook(JSON.stringify(req.body), signature, "whsec_your_secret")) {
    return res.status(401).json({ error: "Invalid signature" });
  }
  
  if (event === "scan.honeypot") {
    console.log(`🚨 Honeypot: ${req.body.data.name}`);
  }
  
  res.json({ status: "ok" });
});