DEV Community: Nikolaos Dimitriadis

Screening the payee of an x402 payment with Privy: OFAC, UN, EU and UK in one signed call

Nikolaos Dimitriadis — Thu, 08 Oct 2026 18:20:21 +0000

Privy has a good recipe for blocking x402 payments to sanctioned addresses: https://docs.privy.io/recipes/agent-integrations/x402-sanctions-screening

The enforcement point is Privy's policy engine. You load a denylist into a condition set, and Privy refuses to sign a payment whose recipient is on it. The recipe is clear about what it leaves to you: loading the addresses is "general code, so it is not reproduced here", the example source is the OFAC SDN list, and it suggests pairing the denylist with a screening provider.

This post shows one way to add that second layer, with a few lines of code and no extra account or API key.

What it adds

Before the agent pays an x402 endpoint, it asks a screening service to read that endpoint's own 402 and check every payTo it advertises against four lists: OFAC SDN, UN Consolidated, EU and UK. The answer is signed (EIP-191), with each list reported separately and its own version date, so you can keep it as a record of what was checked.

The check is itself paid over x402: 0.01 USDC on Base or Solana. The same wallet that pays the target pays for the check; in the setup below, that is your Privy wallet.

Keep the Privy policy as the control that is enforced at signing. Treat this as an extra layer: more lists than OFAC alone, and a signed record per payment for your audit trail.

The code (Node 20 or newer)

npm install @privy-io/node@0.35.0 @x402/fetch@2.17.0
# @privy-io/node/x402 also imports these at load time, so install them too:
npm install @solana/kit@^5.1.0 @x402/svm@2.17.0

import { createX402Client } from '@privy-io/node/x402';
import { wrapFetchWithPayment } from '@x402/fetch';

const SCREEN = 'https://sanctions.nsgoods.org/screen-url?url=';

// Pay the target only if every payTo it advertises is clear on all four lists.
// Anything else (deny, review, an error, a timeout) means do not pay.
export async function screenThenFetch(fetchWithPayment, targetUrl, init) {
  let res, body;
  try {
    res = await fetchWithPayment(SCREEN + encodeURIComponent(targetUrl));
    body = await res.json();
  } catch {
    throw new Error('screening unavailable: do not pay');
  }
  if (res.status !== 200 || body.verdict !== 'clean') {
    throw new Error(`payee not clear (${res.status} ${body?.verdict ?? 'no verdict'}): do not pay`);
  }
  return fetchWithPayment(targetUrl, init);
}

// Privy wallet, as in Privy's x402 docs
const x402client = createX402Client(privy, { walletId: wallet.id, address: wallet.address });
const fetchWithPayment = wrapFetchWithPayment(fetch, x402client);

const response = await screenThenFetch(fetchWithPayment, 'https://api.example.com/premium');

The verdict is clean only when every payee is clear on all four lists. deny means an OFAC match. review means a UN, EU or UK match, or a list that could not be checked. A bad, unreachable or non x402 URL returns 400, 422 or 502 and you are not charged.

Limits

The check reads the 402 at the moment you call it. The response includes quote_sha256 and quote_read_at, so you can log exactly what was checked, but the Privy policy is still what enforces at signing.
Passing means the payee is not on these four lists at their stated version dates. It says nothing about indirect exposure or where the funds go next. Not legal advice.
We tested screenThenFetch on Base with @x402/fetch 2.17.0 and a plain EVM wallet: a clean payee was screened and then paid, and a non x402 URL was refused with no payment. We checked that @privy-io/node 0.35.0 exports createX402Client, but we have not run a payment with a Privy account.

Free signed sample of the response: https://sanctions.nsgoods.org/screen-url/preview
Node and Python examples, with offline signature verification for /screen-multi: https://github.com/Nikoble1926/sanctions-check-before-pay
OpenAPI: https://sanctions.nsgoods.org/openapi.json

Check the payee before your AI agent pays it (x402, Node and Python)

Nikolaos Dimitriadis — Wed, 07 Oct 2026 14:37:09 +0000

An AI agent that pays over x402 reads a payTo address from a 402 response and sends USDC to it. Some agent wallets already let the owner set a daily budget, a per transaction limit and approved domains. A check on the address itself is a separate question: is the wallet you are about to pay on a sanctions list?

This post shows a small pattern for that, with working Node and Python examples. The full code is here: https://github.com/Nikoble1926/sanctions-check-before-pay

What the check does

One paid call screens a wallet address against four lists: OFAC SDN, UN Consolidated, EU and UK. The response is signed and reports each list separately, matched or clear, with that list's version date. It costs 0.01 USDC per call, paid over x402 itself, on Base or Solana. No account, no API key.

GET https://sanctions.nsgoods.org/screen-multi?address=<payTo>&chain=<optional hint>

There is a free signed sample of the exact response shape:

GET https://sanctions.nsgoods.org/screen-multi/preview

The one rule that matters: fail closed

The response has a headline verdict (clean, deny or indeterminate_ofac_unavailable) and an any_list_match flag that covers all four lists. The headline verdict on its own only speaks for OFAC. So the decision uses both, and it treats everything that is not an explicit clean answer as a no:

export const decide = (status, d) =>
  status === 200 && !!d && d.verdict === "clean" && d.any_list_match === false;

deny, indeterminate_ofac_unavailable, a 400, a 5xx, a timeout or a body that is not JSON all mean: do not pay. We had this wrong in our first draft. The script said "pay" when the OFAC feed was unavailable, which is the worst possible failure for a check like this. A check that cannot run must never turn into a yes.

Run it

Node 20 or newer:

npm install
EVM_PRIVATE_KEY=0x... node check-before-pay.mjs <payTo address> [chain]

Python:

pip install -r requirements.txt
EVM_PRIVATE_KEY=0x... python check_before_pay.py <payTo address> [chain]

Exit code 0 means clean, go ahead. Any other exit code means do not pay, so you can drop it in front of the payment step of an agent or a script. Without EVM_PRIVATE_KEY both scripts stop at the 402 and print the price, so you can try them without a wallet. Use a low balance hot wallet for the key, never your main one.

Two things we only found by testing on a clean machine, in case they save you time:

With @x402/axios, the payment happens when the first 402 comes back as an error. If you set validateStatus: () => true on the paying client, the 402 counts as a success and the client never pays. The example uses validateStatus: s => s !== 402, so 400 and 5xx still do not throw.
The Python x402 EVM signer needs web3 installed (the x402[evm] extra). Without it, the import fails before anything runs. The requirements.txt in the repo pins it.

Verify the answer yourself

The response is signed, so you do not have to trust the transport:

node verify-signature.mjs

It fetches the free preview and recovers the signer offline. The service signs the body without signed_by and signature, as compact JSON with sorted keys and non ASCII characters escaped, with an Ethereum personal_sign. Expected signer: 0x57fF0F084Cba33e6761503f90eEF0Da9F159350c. The one trap here: the escaping. JavaScript's JSON.stringify leaves non ASCII characters as they are, so the verifier escapes them by hand to match.

Limits

Not legal advice. Passing the rule means the address is not on these four lists at their stated version dates, nothing more. It says nothing about who controls the wallet or where its funds came from.

Code, MIT licensed: https://github.com/Nikoble1926/sanctions-check-before-pay
More about the service: https://x402.nsgoods.org