DEV Community: PublicAML

Free Crypto KYT API — Enrich Sandbox, Sanction Checks, and Wallet Pre-Send Code

PublicAML — Mon, 27 Jul 2026 02:32:37 +0000

Free Crypto KYT API — Enrich Sandbox, Sanction Checks, and Wallet Pre-Send Code

Interactive console + docs live at intelapi.publicaml.org. Same payload, same JSON your backend gets. This post turns that API into shippable code.

Base URL: https://intelapi.publicaml.org
Auth (public enrich path): none
Chains: ETH, BTC, TRON, BSC

Core: `POST /v1/enrich`

curl -sS -X POST 'https://intelapi.publicaml.org/v1/enrich' \
  -H 'Content-Type: application/json' \
  -d '{
    "addresses":[{"wallet_address":"0x67d40ee1a85bf4a4bb7ffae16de985e8427b6b45","chain":"ETH"}],
    "include":["aml_score","category"],
    "top_n":5
  }' | jq '.entities[0] | {label, category, sanctioned, aml_score}'

Live shape for that OFAC example: sanctioned: true, aml_score: 100, label Chatex (OFAC Sanctioned).

Rule #1 from the docs: sanctioned: true overrides everything else — block even if category looks like cex.

Optional include[]: aml_score | category | counterparties | source_of_funds. Cheap probe:

curl -sS -X POST 'https://intelapi.publicaml.org/v1/enrich' \
  -H 'Content-Type: application/json' \
  -d '{"addresses":[{"wallet_address":"0x9696f59e4d72e237be84ffd425dcad154bf96976","chain":"ETH"}],"include":["category"]}'

JavaScript — decision helper for Send

const BASE = "https://intelapi.publicaml.org";
const BAD = new Set(["mixer","sanction","scam","phishing","romance","hack","darknet","ransomware","terrorism"]);

export async function enrichAddress(wallet_address, chain = "ETH", include) {
  const res = await fetch(`${BASE}/v1/enrich`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      addresses: [{ wallet_address, chain }],
      include: include ?? ["aml_score","category","counterparties","source_of_funds"],
      top_n: 10,
    }),
  });
  if (!res.ok) throw new Error(`enrich ${res.status}`);
  const data = await res.json();
  const entity = data.entities?.[0];
  if (!entity) throw new Error(JSON.stringify(data.not_found ?? "empty"));
  return entity;
}

export function decideSend(entity) {
  if (entity.sanctioned === true) return { action: "block", reason: "sanctioned" };
  const score = Number(entity.aml_score ?? 0);
  if (score >= 60) return { action: "review", reason: "high", score };      // docs: high
  if (score >= 25) return { action: "monitor", reason: "medium", score };    // docs: medium
  const bad = (entity.counterparties || []).filter(cp => BAD.has(String(cp.category||"").toLowerCase()));
  if (bad.length) return { action: "review", reason: "bad_cp", bad };
  const sof = entity.source_of_funds || {};
  if (sof.risk_summary === "high" || (sof.top_sources||[]).some(s => s.sanctioned)) {
    return { action: "review", reason: "sof" };
  }
  return { action: "allow", score, label: entity.label, category: entity.category };
}

// before wagmi sendTransaction / ethers send
export async function assertSendable(to, chain = "ETH") {
  const entity = await enrichAddress(to, chain);
  const d = decideSend(entity);
  if (d.action === "block") throw new Error(`KYT block: ${entity.label}`);
  return { entity, decision: d };
}

Python — CLI for desks / bots

import json, sys, requests
BASE = "https://intelapi.publicaml.org"
BAD = {"mixer","sanction","scam","phishing","romance","hack","darknet","ransomware","terrorism"}

def enrich(wallet, chain="ETH"):
    r = requests.post(f"{BASE}/v1/enrich", json={
        "addresses":[{"wallet_address": wallet, "chain": chain}],
        "include":["aml_score","category","counterparties","source_of_funds"],
        "top_n": 10,
    }, timeout=60)
    r.raise_for_status()
    data = r.json()
    if not data.get("entities"):
        raise SystemExit(data.get("not_found"))
    return data["entities"][0]

def decide(e):
    if e.get("sanctioned") is True: return {"action":"block","reason":"sanctioned"}
    score = float(e.get("aml_score") or 0)
    if score >= 60: return {"action":"review","score":score}
    if score >= 25: return {"action":"monitor","score":score}
    if any(str(cp.get("category") or "").lower() in BAD for cp in e.get("counterparties") or []):
        return {"action":"review","reason":"bad_cp"}
    return {"action":"allow","score":score,"label":e.get("label")}

if __name__ == "__main__":
    e = enrich(sys.argv[1], sys.argv[2] if len(sys.argv)>2 else "ETH")
    print(json.dumps({"decision": decide(e), "label": e.get("label"), "aml_score": e.get("aml_score"), "sanctioned": e.get("sanctioned")}, indent=2))

More endpoints worth wiring

# edges between two addresses
curl -sS -X POST 'https://intelapi.publicaml.org/v1/transactions' \
  -H 'Content-Type: application/json' \
  -d '{"from":"0x4d5e63f1981444a4923f94fea61596b53a057113","to":"0xdd3d3c05a672b8a1112e158cd2fc6f577c2b6e1f","chain":"BSC","limit":20}'

# targeted counterparty / category query
curl -sS -X POST 'https://intelapi.publicaml.org/v1/counterparties' \
  -H 'Content-Type: application/json' \
  -d '{"wallet_address":"0x9696f59e4d72e237be84ffd425dcad154bf96976","chain":"ETH","category":"mixer"}'

# dataset coverage
curl -sS 'https://intelapi.publicaml.org/stats' | jq '{clusters, counterparties}'

Also on the docs page: /v1/entities, /v1/cluster-mappings, /v1/address-transactions, /health.

Field cheat sheet

Signal	Action
`sanctioned: true`	refuse
`aml_score >= 60`	high → review
`aml_score 25..59`	medium → monitor
dirty `counterparties[].category`	investigate
`cluster_size > 1000`	treat as entity via `cluster_id`

Open the sandbox, paste an address, hit Copy as curl, then mirror that JSON in your wallet preflight. Product site: publicaml.org.

Build a Free Telegram Bot for Crypto Wallet AML / KYT Checks

PublicAML — Mon, 27 Jul 2026 02:06:08 +0000

Build a Free Telegram Bot for Crypto Wallet AML / KYT Checks

Support channels and OTC chats drown in “is this address safe?” messages. A bot that replies with a KYT / AML score in under a second is a force multiplier — and you can wire it with a free enrich API (no key) from PublicAML.

There is already an official bot at @publicaml. This article shows how to build your own branded checker for a community or desk.

Prerequisites

Python 3.10+
A bot token from @BotFather
pip install pyTelegramBotAPI requests (or python-telegram-bot — same idea)

Core: enrich helper

import os
import re
import requests

ENRICH = "https://intelapi.publicaml.org/v1/enrich"

EVM_RE = re.compile(r"^0x[a-fA-F0-9]{40}$")
# simplistic BTC bech32 / legacy sniff — extend as needed
BTC_RE = re.compile(r"^(bc1|[13])[a-zA-HJ-NP-Z0-9]{25,62}$")


def detect_chain(addr: str) -> str | None:
    if EVM_RE.match(addr):
        return "ETH"
    if BTC_RE.match(addr):
        return "BTC"
    return None


def kyt(addr: str, chain: str) -> dict:
    r = requests.post(
        ENRICH,
        json={"addresses": [{"wallet_address": addr, "chain": chain}]},
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["entities"][0]


def format_report(e: dict) -> str:
    score = e.get("aml_score")
    label = e.get("label") or "—"
    category = e.get("category") or "—"
    if score is None:
        return "No score returned."
    if score >= 70:
        verdict = "HIGH RISK — do not send blindly"
    elif score >= 40:
        verdict = "MEDIUM — review carefully"
    else:
        verdict = "LOW — still DYOR"
    return (
        f"*KYT / AML report*\n"
        f"Score: `{score}`\n"
        f"Label: `{label}`\n"
        f"Category: `{category}`\n"
        f"Chain: `{e.get('chain')}`\n"
        f"Verdict: {verdict}\n"
        f"_Powered by PublicAML — https://publicaml.org/_"
    )

Bot handlers (pyTelegramBotAPI)

import telebot

bot = telebot.TeleBot(os.environ["TELEGRAM_BOT_TOKEN"])


@bot.message_handler(commands=["start", "help"])
def help_cmd(m):
    bot.reply_to(
        m,
        "Send /check <address> for a free KYT/AML screen.\n"
        "Example: /check 0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
    )


@bot.message_handler(commands=["check"])
def check_cmd(m):
    parts = (m.text or "").split(maxsplit=1)
    if len(parts) < 2:
        bot.reply_to(m, "Usage: /check <wallet_address>")
        return
    addr = parts[1].strip()
    chain = detect_chain(addr)
    if not chain:
        bot.reply_to(m, "Could not detect chain (supported demo: ETH / BTC).")
        return
    try:
        entity = kyt(addr, chain)
        bot.reply_to(m, format_report(entity), parse_mode="Markdown")
    except Exception as exc:
        bot.reply_to(m, f"Enrich failed: {exc}")


bot.infinity_polling()

Run:

export TELEGRAM_BOT_TOKEN=123:ABC
python bot.py

Production notes

Respect the free-tier rate limit (~1k/h): debounce per chat, cache identical addresses for 5–15 minutes.
Log only hashes/prefixes if you store history — addresses are sensitive.
For desks, add an allowlist of staff chat IDs.
Extend detect_chain for TRON / others as your product supports them.

Why bots convert search traffic

People Google “check wallet AML free” and “KYT telegram bot”. Pair this tutorial with the live product bot and the REST API so readers can graduate from chat → API → wallet integration.

Ship it, pin /check in your community, and stop answering the same risk question by hand.

Add Pre-Transaction KYT Screening to wagmi / ethers (Free API)

PublicAML — Mon, 27 Jul 2026 02:00:12 +0000

Add Pre-Transaction KYT Screening to wagmi / ethers (Free API)

Most wallet UX bugs that lose user funds are not smart-contract bugs — they are wrong destination bugs. A 150ms KYT (Know Your Transaction) check on to before sendTransaction is cheap insurance.

Here is a pattern that works with ethers and wagmi, using the free PublicAML enrich API (publicaml.org).

Shared enrich helper

export type Risk = {
  amlScore: number;
  label?: string | null;
  category?: string | null;
};

export async function enrichEvmAddress(address: `0x${string}`): Promise<Risk> {
  const res = await fetch("https://intelapi.publicaml.org/v1/enrich", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      addresses: [{ wallet_address: address, chain: "ETH" }],
    }),
  });
  if (!res.ok) throw new Error(`enrich ${res.status}`);
  const entity = (await res.json()).entities?.[0];
  return {
    amlScore: Number(entity?.aml_score ?? 0),
    label: entity?.label,
    category: entity?.category,
  };
}

export function assertSendable(risk: Risk, hardLimit = 70) {
  if (risk.amlScore >= hardLimit) {
    throw new Error(
      `KYT block: score ${risk.amlScore}` +
        (risk.label ? ` (${risk.label})` : "")
    );
  }
}

ethers v6

import { BrowserProvider } from "ethers";

async function sendWithKyt(to: `0x${string}`, valueWei: bigint) {
  const risk = await enrichEvmAddress(to);
  if (risk.amlScore >= 40 && risk.amlScore < 70) {
    const ok = window.confirm(
      `Medium risk destination (score ${risk.amlScore}` +
        `${risk.label ? `, ${risk.label}` : ""}). Continue?`
    );
    if (!ok) return;
  }
  assertSendable(risk);

  const provider = new BrowserProvider(window.ethereum);
  const signer = await provider.getSigner();
  return signer.sendTransaction({ to, value: valueWei });
}

wagmi (React)

Call enrich in the click handler before writeContract / sendTransaction:

import { useSendTransaction } from "wagmi";
import { parseEther } from "viem";
import { enrichEvmAddress, assertSendable } from "./kyt";

export function SendButton({ to }: { to: `0x${string}` }) {
  const { sendTransactionAsync, isPending } = useSendTransaction();

  async function onSend() {
    const risk = await enrichEvmAddress(to);
    // Optional: setRiskBanner(risk) for inline UI
    assertSendable(risk);
    await sendTransactionAsync({ to, value: parseEther("0.01") });
  }

  return (
    <button disabled={isPending} onClick={onSend}>
      Send with KYT
    </button>
  );
}

UX tips

Show score + label (“CEX / Bitfinex”) — raw numbers alone create support tickets.
Cache enrich results for a few minutes per address while the user edits amount.
Do not block the whole app if enrich fails — fail open with a visible “risk check unavailable” banner, or fail closed for high-value transfers (product choice).
Same pattern works for token transfers: screen the recipient, not only the router.

Why free matters here

Commercial KYT often means waiting on sales. For open wallets and hackathon UX, a public enrich call unblocks shipping. PublicAML’s free tier is documented on the site (~1k req/h) — plenty for client-side gates with a small backend cache.

Ship the gate. Then tune thresholds. Users will never thank you for the scam they did not send to — but your support inbox will.

Free Crypto AML / KYT Address Screening in Python (No API Key)

PublicAML — Mon, 27 Jul 2026 01:59:56 +0000

Free Crypto AML / KYT Address Screening in Python (No API Key)

Need a quick Know Your Transaction (KYT) / AML gate in a bot, ETL job, or OTC ops script? You can enrich a wallet address in one HTTP call — no vendor signup for the free tier.

Endpoint: POST https://intelapi.publicaml.org/v1/enrich

Product: https://publicaml.org/

Minimal client

import requests

ENRICH_URL = "https://intelapi.publicaml.org/v1/enrich"

def enrich_address(wallet_address: str, chain: str = "ETH") -> dict:
    r = requests.post(
        ENRICH_URL,
        json={"addresses": [{"wallet_address": wallet_address, "chain": chain}]},
        timeout=30,
    )
    r.raise_for_status()
    entities = r.json().get("entities") or []
    if not entities:
        raise RuntimeError("empty enrich response")
    return entities[0]


def decide(entity: dict) -> str:
    score = float(entity.get("aml_score") or 0)
    if score >= 70:
        return "block"
    if score >= 40:
        return "warn"
    return "allow"


if __name__ == "__main__":
    e = enrich_address("0x742d35Cc6634C0532925a3b844Bc454e4438f44e", "ETH")
    print(
        {
            "decision": decide(e),
            "aml_score": e.get("aml_score"),
            "label": e.get("label"),
            "category": e.get("category"),
            "chain": e.get("chain"),
        }
    )

Example shape of useful fields:

aml_score — 0–100 risk score
label / category — entity tagging (e.g. CEX name)
aml_score_breakdown — exposure / propagated sources
behavioral_signals — heuristics like cross-chain hopping
counterparties — recent interaction context

Batch a small list

def enrich_many(pairs: list[tuple[str, str]]) -> list[dict]:
    """pairs = [(address, chain), ...] — keep batches modest for free-tier rate limits."""
    r = requests.post(
        ENRICH_URL,
        json={
            "addresses": [
                {"wallet_address": addr, "chain": chain} for addr, chain in pairs
            ]
        },
        timeout=60,
    )
    r.raise_for_status()
    return r.json()["entities"]

Free tier guidance from the product site: about 1k requests/hour. Cache stable labels aggressively (CEX deposit addresses do not change hourly).

Tiny CLI for ops

python - <<'PY'
import sys, json, requests
addr, chain = sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "ETH"
e = requests.post(
    "https://intelapi.publicaml.org/v1/enrich",
    json={"addresses": [{"wallet_address": addr, "chain": chain}]},
    timeout=30,
).json()["entities"][0]
print(json.dumps({
    "score": e["aml_score"],
    "label": e.get("label"),
    "category": e.get("category"),
}, indent=2))
PY

Where this fits

Telegram / Discord bots that reply with risk before users tip
OTC deal intake: paste counterparty → auto score
Nightly jobs that re-score watchlists

This is address KYT, not full KYC. Pair it with your own policies for custody and fiat rails.

More at publicaml.org — free forever for this public enrich path.

KYT vs KYC vs AML for Crypto Developers (With a Free Address Check)

PublicAML — Mon, 27 Jul 2026 01:50:07 +0000

KYT vs KYC vs AML for Crypto Developers (With a Free Address Check)

If you build wallets, OTC desks, NFT checkouts, or DeFi frontends, compliance vocabulary shows up in every roadmap. The acronyms get mashed together. Here is the practical split — and a free way to ship the part users actually feel: screening the destination before send.

KYC — Know Your Customer

Question: Who is using my product?

Typical signals: passport / ID, selfie, proof of address, sanctions name screening.

KYC is identity. It does not tell you whether 0xabc… is a mixer exit or a sanctioned cluster two hops away.

AML — Anti-Money Laundering

Question: Are we preventing illicit finance end-to-end?

AML is the program: policies, monitoring, SAR/STR workflows, travel-rule where required, ongoing review. KYC is one control inside AML. Transaction monitoring and KYT are others.

KYT — Know Your Transaction

Question: Is this payment (or counterparty) risky?

KYT looks at blockchain graph risk: exposure to sanctions, hacks, scams, mixers, darknet, etc. For a non-custodial wallet the highest-ROI check is usually:

Before broadcast, enrich the to address. If risk is high, warn or block.

That is KYT in the product sense — even when the backend labels the field aml_score.

What to implement first (builder priority)

Product	First control	Why
Non-custodial wallet	Destination KYT	User still controls keys; you can still stop them sending to a drain
Custodial exchange	KYC + deposit/withdraw KYT	Regulated perimeter
OTC desk	Counterparty KYT + deal notes	Speed + court-ready trails
DeFi UI	Recipient / router awareness	UX warnings before approve/send

Free KYT call you can ship today

PublicAML exposes a public enrich API — no key for the free tier:

const res = await fetch("https://intelapi.publicaml.org/v1/enrich", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    addresses: [
      {
        wallet_address: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
        chain: "ETH",
      },
    ],
  }),
});

const { entities } = await res.json();
const e = entities[0];

console.log({
  score: e.aml_score, // 0–100 KYT-style risk
  label: e.label, // e.g. Bitfinex
  category: e.category, // e.g. cex
});

Use thresholds that match your risk appetite (example: warn ≥ 40, block ≥ 70), and always show label / category so the UX is explainable.

Common mistakes

Treating KYC as KYT — verifying the user does not clear the destination.
Only screening after send — users need the warning before they lose funds.
Score without context — show why (mixer hop, sanction exposure, known CEX).
Paying for keys on day one — prototype with a free endpoint, then graduate if you need SLAs / private datasets.

Bottom line

KYC = identity
AML = the compliance program
KYT = risk of the money path / counterparty

If you only have one engineering sprint, add destination KYT on send. It is the control that stops the most “I sent to a scam address” support tickets — and you can start with a free API at publicaml.org.

Free KYT for Crypto Wallets — Check Address Risk Before You Send (JavaScript)

PublicAML — Mon, 27 Jul 2026 01:49:44 +0000

Free KYT for Crypto Wallets — Check Address Risk Before You Send (JavaScript)

Before a user hits Send, you usually know the destination address. That is the cheapest place to run KYT (Know Your Transaction) / AML screening: if the counterparty looks like a mixer hop, sanctioned cluster, or known scam sink, warn or block.

Most commercial AML/KYT APIs need contracts, keys, and paid credits. You can ship a working pre-send check with a free public endpoint and ~20 lines of JavaScript.

What you will build

A tiny helper that:

Takes a wallet address + chain (ETH, BTC, …)
Calls POST https://intelapi.publicaml.org/v1/enrich
Returns an aml_score (0–100) plus labels useful for UX

No API key. Rate limit on the free tier is roughly 1k requests/hour — enough for wallets, bots, and demos.

Copy-paste example

/**
 * Free KYT / AML address enrichment (no API key).
 * Docs / product: https://publicaml.org/
 */
export async function checkAddressRisk(walletAddress, chain = "ETH") {
  const res = await fetch("https://intelapi.publicaml.org/v1/enrich", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      addresses: [{ wallet_address: walletAddress, chain }],
    }),
  });

  if (!res.ok) {
    throw new Error(`PublicAML enrich failed: ${res.status}`);
  }

  const { entities } = await res.json();
  const entity = entities?.[0];
  if (!entity) throw new Error("Empty enrich response");

  return {
    address: entity.wallet_address,
    chain: entity.chain,
    amlScore: entity.aml_score, // 0–100
    label: entity.label, // e.g. "Bitfinex"
    category: entity.category, // e.g. "cex"
    breakdown: entity.aml_score_breakdown,
    signals: entity.behavioral_signals,
  };
}

export function riskLevel(score) {
  if (score >= 70) return "high";
  if (score >= 40) return "medium";
  return "low";
}

// Example
const risk = await checkAddressRisk(
  "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
  "ETH"
);
console.log(risk.amlScore, risk.label, riskLevel(risk.amlScore));

How to use the score in a wallet UX

Score	Suggested UX
0–39	Allow (optional soft info if `category` is interesting)
40–69	Warning modal: show label / top risk categories
70–100	Hard block or require typed confirmation

Important nuance: a known CEX deposit address can show infrastructure floors in the breakdown while the surfaced aml_score stays low. Always display label + category next to the number so users understand why.

async function beforeSend(to, chain) {
  const r = await checkAddressRisk(to, chain);
  const level = riskLevel(r.amlScore);

  if (level === "high") {
    throw new Error(
      `Blocked: high KYT risk (${r.amlScore}). Label: ${r.label ?? "unknown"}`
    );
  }

  if (level === "medium") {
    // showConfirm(...) in your UI
    console.warn("Medium risk destination", r);
  }

  return r;
}

KYT vs KYC vs AML (30-second version)

KYC — who the user is (identity docs).
AML — policies + monitoring to prevent money laundering.
KYT — risk of this payment path (address / hops / exposure) right before or after a transfer.

Wallet and DeFi UIs mostly need KYT on the destination (and sometimes the user’s own funding sources). This API is address enrichment — perfect for pre-send gates.

Try it from the shell

curl -sS -X POST 'https://intelapi.publicaml.org/v1/enrich' \
  -H 'Content-Type: application/json' \
  -d '{"addresses":[{"wallet_address":"0x742d35Cc6634C0532925a3b844Bc454e4438f44e","chain":"ETH"}]}' \
  | jq '.entities[0] | {aml_score, label, category, chain}'

Where to go next

Product + dashboard: https://publicaml.org/
Telegram bot for manual checks: @publicaml
Add the same call in Python, Go, or a wagmi sendTransaction wrapper

Free forever for this use case — if you ship a wallet or OTC desk, there is no excuse not to screen the counterparty before broadcast.

DEV Community: PublicAML

Free Crypto KYT API — Enrich Sandbox, Sanction Checks, and Wallet Pre-Send Code

Free Crypto KYT API — Enrich Sandbox, Sanction Checks, and Wallet Pre-Send Code

Core: POST /v1/enrich

JavaScript — decision helper for Send

Python — CLI for desks / bots

More endpoints worth wiring

Field cheat sheet

Build a Free Telegram Bot for Crypto Wallet AML / KYT Checks

Build a Free Telegram Bot for Crypto Wallet AML / KYT Checks

Prerequisites

Core: enrich helper

Bot handlers (pyTelegramBotAPI)

Production notes

Why bots convert search traffic

Add Pre-Transaction KYT Screening to wagmi / ethers (Free API)

Add Pre-Transaction KYT Screening to wagmi / ethers (Free API)

Shared enrich helper

ethers v6

wagmi (React)

UX tips

Why free matters here

Free Crypto AML / KYT Address Screening in Python (No API Key)

Free Crypto AML / KYT Address Screening in Python (No API Key)

Minimal client

Batch a small list

Tiny CLI for ops

Where this fits

KYT vs KYC vs AML for Crypto Developers (With a Free Address Check)

KYT vs KYC vs AML for Crypto Developers (With a Free Address Check)

KYC — Know Your Customer

AML — Anti-Money Laundering

KYT — Know Your Transaction

What to implement first (builder priority)

Free KYT call you can ship today

Common mistakes

Bottom line

Free KYT for Crypto Wallets — Check Address Risk Before You Send (JavaScript)

Free KYT for Crypto Wallets — Check Address Risk Before You Send (JavaScript)

What you will build

Copy-paste example

How to use the score in a wallet UX

KYT vs KYC vs AML (30-second version)

Try it from the shell

Where to go next

Core: `POST /v1/enrich`