DEV Community: PublicAML

Screen a crypto wallet without leaving Claude or ChatGPT (PublicAML MCP server)

PublicAML — Wed, 02 Sep 2026 16:16:07 +0000

AI assistants are great at reasoning about on-chain data — but they can't see whether a wallet is sanctioned, tied to a scam, or where its funds came from unless you give them a tool. PublicAML now ships an MCP server, so Claude and ChatGPT can run AML/KYT checks directly in the chat.

What it does

Once connected, the assistant can call three tools against PublicAML's keyless backend:

screen_address — risk score, sanctions status, category and source of funds for a BTC/ETH/BNB Chain/TRON address
trace_funds — follow where funds moved
list_counterparties — who the address transacted with

No API key, no account — it is a non-profit public good.

Two ways to add it

Remote (zero install) — add the hosted server as a custom connector:

https://mcp.publicaml.org/mcp

In Claude: Settings → Connectors → Add custom connector → paste the URL. In ChatGPT: add it as a custom MCP connector. Then ask "screen 0x28C6…d60 for AML risk" and it calls the tool.

Local (stdio) — for developers who want it in their own MCP client:

npx @publicaml/mcp-server

Both are listed in the official MCP registry (search "publicaml" at registry.modelcontextprotocol.io).

Why it matters

Pre-transaction screening usually means a paid API or a separate dashboard. Putting it behind MCP means the check happens where you already are — mid-conversation, mid-investigation — for free.

Try the API directly: https://publicaml.org/api · Free wallet check: https://publicaml.org/free-crypto-aml/

A free, keyless crypto AML/KYT API (curl, Python, JS)

PublicAML — Wed, 02 Sep 2026 04:32:37 +0000

Most crypto AML/KYT APIs are sales-led or per-call. If you just need to screen a wallet before a transaction, PublicAML is a non-profit with a free, keyless KYT API: POST an address and get back an AML risk score, sanctions/scam exposure, entity category and source of funds. No API key to start — an optional key only raises the rate limit. Covers Bitcoin, Ethereum, BNB Chain and TRON.

curl

curl -s -X POST https://intelapi.publicaml.org/v1/enrich \
  -H 'Content-Type: application/json' \
  -d '{"addresses":[{"wallet_address":"0x28c6c06298d514db089934071355e5743bf21d60","chain":"ethereum"}]}'

Python

import requests

r = requests.post(
    "https://intelapi.publicaml.org/v1/enrich",
    json={"addresses": [{"wallet_address": "0x28c6...d60", "chain": "ethereum"}]},
    timeout=20,
)
entity = r.json()["entities"][0]
print(entity["aml_score"], entity["category"])

JavaScript / TypeScript

const res = await fetch("https://intelapi.publicaml.org/v1/enrich", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    addresses: [{ wallet_address: "0x28c6...d60", chain: "ethereum" }],
  }),
});
const { entities } = await res.json();
console.log(entities[0].aml_score, entities[0].category);

The response returns an AML score, an entity category (cex, mixer, sanction, hack, scam, ...), cluster info and counterparties with source-of-funds. There are SDKs for JavaScript/TypeScript, Python and Go, plus a Telegram bot for one-off checks.

It is run as a public good, so screening is free — no trial, no monthly cap. Full docs and more examples: https://publicaml.org/crypto-aml-api-examples · API overview: https://publicaml.org/api

How PublicAML publishes criminal crypto addresses and gets them indexed by Google

PublicAML — Wed, 02 Sep 2026 00:23:16 +0000

When someone loses money to a crypto scam, or an investigator traces stolen funds, the first question is always the same: has this address been flagged before? For most people the answer is locked behind enterprise tools that cost five or six figures a year. PublicAML takes the opposite approach — it publishes flagged addresses as public, search-engine-indexable pages, so anyone can find them for a free AML check.

What we publish

PublicAML maintains risk records on roughly 200,000 crypto addresses across Bitcoin, Ethereum, BNB Chain and TRON — sanctioned entities, hacks, scams, mixers, ransomware and labelled services. Every one of them gets its own public page:

https://publicaml.org/address/<chain>/<address>/

Each page shows the AML risk score, sanctions status, how many hops the funds are from a flagged source, the entity category, and the propagation path our engine traced. These pages are server-rendered, carry robots: index, follow, are self-canonical, and hold real content — everything a search engine needs to index them.

How they actually get indexed

Indexable is not the same as indexed. A young domain with 200,000 template pages reachable only from a sitemap gets filed under "Discovered — currently not indexed." The fix is internal linking:

Directory hubs. publicaml.org/directory/ lists every flagged address, split by chain and paginated. Each hub links directly to the individual address pages, so every flagged wallet has a crawlable path in — no orphans.
Cross-links between addresses. Risk-relevant addresses link to the sources that flagged them.
Sitemap + IndexNow. New URLs are pushed to IndexNow, which feeds Bing (and from there ChatGPT, Brave and others) within minutes.

Community and partner reports

Anyone can report a criminal address at publicaml.org/victim-reports/. A submitted report becomes a public, indexable page at https://publicaml.org/reports/VR-XXXXXXXX/. The reported address is tagged "community-reported" and surfaces on that address's page, labelled by review stage. Reports from verified partners are trusted and can be promoted straight into the public index.

The transparency loop: a victim reports a scam wallet → it gets a public page → search engines index it → the next person who searches that address sees the warning before they send.

Why publish criminal addresses at all

Because a warning nobody can find protects nobody. Sanctions lists, scam databases and hack attributions exist, but they are scattered and mostly paywalled. Publishing them as free, indexed pages turns them into something a normal person can reach — from a Google search, a wallet, or a Telegram bot. PublicAML is a non-profit; screening and publication are free because they work best as a public good.

Try it

Check any address free: https://publicaml.org/free-crypto-aml/
Browse the directory of flagged wallets: https://publicaml.org/directory/
Report a scam or hacker address: https://publicaml.org/victim-reports/
Keyless KYT API: https://intelapi.publicaml.org

A genuinely free AML check for any crypto wallet (no trial, no API key)

PublicAML — Tue, 01 Sep 2026 07:43:12 +0000

If you've ever searched for a free AML check for a crypto wallet, you've probably noticed the pattern: the result is a free trial, a capped freemium tier, or an "enterprise demo" that means a sales call.

For a lot of use cases — an OTC desk vetting an incoming address, a P2P trader checking a counterparty, someone about to send USDT to a new wallet — you don't need a contract. You need to paste an address and see whether it's clean.

What "free" usually hides

Free trial — free for a week or a month, then billed.
Freemium cap — a handful of checks, then paid, usually behind an API key.
Enterprise demo — "free" means a sales call and a five/six-figure contract.

A non-profit alternative

PublicAML is run as a public good, so the check is actually free:

Any Bitcoin, Ethereum, BNB Chain or TRON address
Risk score, sanctions status, entity attribution, source of funds, counterparties
No account, no card, no expiry
A keyless KYT API (intelapi.publicaml.org/v1/enrich) and SDKs (JS/TS, Python, Go)
A Telegram bot at t.me/publicamlbot for one-off checks

It won't replace Chainalysis or TRM for a regulated exchange's full compliance stack — but as a free first-line screen before you move funds, it does the job.

Try it: https://publicaml.org/free-crypto-aml/ · Compare the free options: https://publicaml.org/free-aml-checkers-compared/

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

Screen a crypto wallet without leaving Claude or ChatGPT (PublicAML MCP server)

What it does

Two ways to add it

Why it matters

A free, keyless crypto AML/KYT API (curl, Python, JS)

curl

Python

JavaScript / TypeScript

How PublicAML publishes criminal crypto addresses and gets them indexed by Google

What we publish

How they actually get indexed

Community and partner reports

Why publish criminal addresses at all

Try it

A genuinely free AML check for any crypto wallet (no trial, no API key)

What "free" usually hides

A non-profit alternative

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`