API de detección de phishing en x402. Los agentes IA pagan en USDC.

El argumento en una sola frase

Un agente IA, una aplicación de billetera o una extensión de navegador nos envía cualquier URL. Devolvemos un veredicto de estafa junto con 23 señales de amenaza. Cada solicitud cuesta $0.001 USDC, pagado en cadena en Solana o Base. Sin registro, sin claves de API, sin llamada de ventas. Ese es el producto completo.

La parte interesante no es el motor de detección. La parte interesante es lo que ocurre cuando una API HTTP se convierte silenciosamente en un negocio en cadena independiente. x402 es el primitivo que hace esto posible, y el resto de este artículo lo explica.

Qué es realmente x402

HTTP 402 ha estado reservado como Pago Requerido desde la especificación original de HTTP/1.1 en 1999. Durante veintiséis años estuvo ahí, esperando un protocolo de pago que Internet realmente quisiera adoptar. En 2025, Coinbase publicó una forma concreta que finalmente lo hace utilizable, y x402 es el resultado.

La idea es simple. Un cliente llama a cualquier endpoint HTTP. Si el servidor necesita pago, responde con estado 402 y un cuerpo JSON que describe las opciones de pago aceptadas: cadenas, tokens, montos, direcciones del receptor y un nonce emitido por el servidor. El cliente paga en cadena, reintenta la misma solicitud con un encabezado de firma que prueba que el pago ocurrió, y el servidor verifica y sirve la respuesta real.

Ese único patrón reemplaza toda una pila de repetición en la experiencia del desarrollador: formularios de registro, portales de facturación, paneles de uso, niveles de límite de tasa, rotación de claves de API y correos de cobranza. Un endpoint, un precio, una liquidación en cadena. El flujo de tarjeta de crédito, pero para máquinas.

Dos observaciones al construir esto:

• La latencia está bien. Solana liquida en ~400 ms, Base en ~2 segundos para una transferencia USDC. La solicitud completa tarda entre 1 y 3 segundos incluyendo la verificación del servidor. Eso es más lento que una llamada a API normal pero más rápido que cualquier flujo de registro, y los agentes no parpadean ante unos pocos segundos.
• "Pago Requerido" es un primitivo HTTP real. No es un parche. Cualquier cliente compatible con HTTP puede analizar un 402, leer el array de aceptados y decidir pagar. Los frameworks de agentes encajan de forma nativa porque ya manejan códigos de estado HTTP; solo necesitan una billetera.

Por qué importa ahora (los agentes IA no tienen tarjetas de crédito)

Los agentes IA en 2026 tienen un problema estructural. Son excelentes para llamar APIs, pero terribles para registrarse en ellas. Un agente que construye un flujo de investigación de productos necesita obtener datos de veinte fuentes especializadas, y diecinueve de ellas requieren un correo, una contraseña, una tarjeta de crédito y el consentimiento de un humano. Esa fricción se acumula.

x402 le da al agente una forma diferente: aquí hay una billetera, aquí hay un presupuesto, aquí hay una lista de endpoints que aceptan pago — ve a hacer tu trabajo. Toda empresa que desarrolla software agéntico choca con este muro tarde o temprano. Elegimos construir para ello primero.

Un endpoint, un precio

La interfaz es deliberadamente mínima.

curl -X POST https://api.safebrowz.com/v1/detect \
  -H "Content-Type: application/json" \
  -d '{"url":"https://trezor-support.com"}'

Primera llamada, sin encabezados de pago → el servidor responde con un desafío 402:

HTTP/2 402 Payment Required
Payment-Required: eyJ4NDAyVmVyc2lvbiI6Mi...  (base64 v2 payload)

{
  "x402Version": 1,
  "status": 402,
  "error": "payment_required",
  "accepts": [
    {
      "scheme": "exact",
      "network": "solana",
      "networkCaip2": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
      "maxAmountRequired": "1000",
      "asset": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
      "payTo": "FLQyppmJYbvQvEPAB4Mv8ZGmxkSXmXUwMACeJ79kdozW",
      "maxTimeoutSeconds": 60,
      "extra": {
        "token": "USDC", "decimals": 6,
        "nonce_binding": "memo",
        "memo_template": "safebrowz:87d311de-..."
      }
    },
    {
      "scheme": "exact",
      "network": "base",
      "networkCaip2": "eip155:8453",
      "maxAmountRequired": "1000",
      "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "payTo": "0xf3bc3a04646F1D721992AeDC07c98FC52FdFC358",
      "extra": {
        "token": "USDC", "decimals": 6, "chainId": 8453,
        "nonce_binding": "eip191",
        "sign_message_template": "safebrowz:87d311de-..."
      }
    }
  ]
}

El cliente elige una cadena, paga 0.001 USDC en cadena vinculando el nonce (SPL-memo en Solana o firma EIP-191 off-chain en Base), y reintenta con un encabezado X-PAYMENT:

POST /v1/detect
Content-Type: application/json
X-PAYMENT: eyJ4NDAyVmVyc2lvbiI6MSwic2NoZW1lIjoiZXhhY3QiLC...

{"url":"https://trezor-support.com"}

El servidor verifica la transacción en cadena, aplica unicidad de nonce (defensa contra repetición), y devuelve el veredicto completo:

HTTP/2 200 OK

{
  "verdict": "danger",
  "trust_score": 8,
  "brand": "Trezor",
  "confidence": 0.97,
  "reason": "This page impersonates Trezor and does not belong to the real brand.",
  "threat_types": [
    "brand_impersonation",
    "credential_phishing",
    "wallet_drainer"
  ],
  "signals": {
    "brand_impersonation": true,
    "credential_phishing": true,
    "wallet_drainer": true,
    "fresh_domain": true,
    "fake_captcha": false,
    "pastejacking": false,
    ...
  },
  "details": {
    "matched_brand": "Trezor",
    "official_domain": "trezor.io"
  }
}

Veintitrés señales booleanas en la respuesta completa, cubriendo cada categoría de amenaza que SafeBrowz rastrea en más de 500 marcas y 100 idiomas.

Dentro del pipeline de detección

El endpoint parece trivial desde afuera, pero cada solicitud pasa por un pipeline de cinco capas. Cada capa está diseñada para salir lo antes posible; cuanto más cerca esté un veredicto del extremo económico, más rápida y menos costosa es la respuesta.

Capa por capa:

1. Validación de URL + ruta rápida para sitios seguros conocidos. Guardia SSRF (bloquea literales de IP privada y nombres reservados), verificación de esquema, límite de longitud. Luego una lista curada de más de 80 dominios de uso doméstico (google.com, trezor.io, metamask.io, github.com, coinbase.com, todas las principales billeteras e intercambios) cortocircuita hacia un veredicto SEGURO sin trabajo posterior.
2. Caché Redis compartida. Los veredictos para dominios populares se almacenan en caché entre todos los llamadores: 14 días para seguro, 30 días para peligro, 7 días para precaución. La tasa de aciertos de caché supera el 80% en producción, manteniendo el costo por solicitud en un error de redondeo.
3. Motor de patrones de URL. Más de treinta firmas de URL de estafa (rutas de drenador de billeteras, patrones de airdrop cripto, formas comunes de phish), lista de TLD desechables, verificación de palabras clave de marca con normalización de homógrafos (rn→m, 0→o, etc.) y distancia de edición Levenshtein-1 (detecta gooogle, microsooft, rnetamask).
4. Obtención de página + análisis de contenido IA. HTML obtenido con un tiempo de espera de 5 segundos y la misma guardia SSRF aplicada a cada redirección. Un modelo de lenguaje extrae señales de la página: marca reclamada vs marca real, patrones de script drenador de billeteras, copia de captcha falso (ClickFix), patrones de Pastejacking, estructura de phishing de credenciales. 23 booleanos más una razón legible en menos de 500 ms. Solo alrededor del 20% del tráfico llega a esta capa; todo lo demás ha sido resuelto por pasos anteriores.
5. Motor de decisión. Conteos de señales + reglas de fuerza de peligro (cualquier señal de wallet_drainer, seed_phrase_phishing, fake_captcha, pastejacking o brand_impersonation fuerza peligro independientemente del conteo positivo), más una sonda DNS para el caso de "el dominio no resuelve". Emite el veredicto final, trust_score, confianza y detalles enriquecidos.

Latencia de extremo a extremo: mediana ~240 ms (dominada por aciertos de caché), p95 ~900 ms (capa de contenido IA), p99 ~2.5 s (tiempos de espera de obtención de página en servidores hostiles).

Múltiples cadenas desde el primer día

Soportamos x402 tanto en Solana mainnet como en Base mainnet. Mismo endpoint, misma forma de respuesta, el cliente elige la cadena en la que ya está su stack de billetera.

Cadena	Token	Vinculación de nonce	Liquida en	Comisión típica
Solana mainnet	USDC (0.001) o SOL (0.00001)	Instrucción SPL-memo	~400 ms	~$0.0002
Base mainnet	USDC (0.001)	Firma off-chain EIP-191	~2 segundos	~$0.002

Solana fue el punto de partida obvio. La instrucción de token SPL transferChecked más una instrucción spl-memo que vincula el nonce a exactamente una transacción hace que la defensa contra repetición sea trivial: el memo está en cadena, es único por tx y no puede desvincularse. La liquidación en menos de un segundo se adapta bien a las cargas de trabajo de agentes.

Base cubre a todos los desarrolladores que ya operan en el ecosistema EVM, ya sea usando viem, wagmi, integraciones de MetaMask o Coinbase Developer Platform. Un nonce puramente en cadena no existe para transferencias ERC-20 (no hay campo memo), por lo que la vinculación del nonce se realiza off-chain: el pagador firma personalmente con EIP-191 el mensaje safebrowz:<nonce>, y la dirección recuperada debe coincidir con el remitente del evento Transfer en cadena. Sin transacción adicional, defensa completa contra repetición.

Cliente completo — TypeScript + viem (Base)

Esta es una implementación funcional. Cabe en una pantalla.

import { createWalletClient, http, parseUnits, erc20Abi } from "viem";
import { base } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const URL = "https://api.safebrowz.com/v1/detect";
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const wallet  = createWalletClient({ account, chain: base, transport: http() });

export async function detect(target: string) {
  // 1. First call — expect 402
  const first = await fetch(URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ url: target }),
  });
  if (first.status !== 402) return first.json();
  const challenge = await first.json();
  const baseEntry = challenge.accepts.find((a: any) => a.network === "base");

  // 2. Pay USDC onchain to the configured receiver
  const txHash = await wallet.writeContract({
    address: USDC_BASE, abi: erc20Abi, functionName: "transfer",
    args: [baseEntry.payTo, parseUnits("0.001", 6)],
  });

  // 3. Sign the off-chain nonce binding (EIP-191 personal_sign)
  const walletSig = await wallet.signMessage({
    message: baseEntry.extra.sign_message_template,
  });

  // 4. Retry with the spec-compliant X-PAYMENT header
  const xPayment = Buffer.from(JSON.stringify({
    x402Version: 1, scheme: "exact", network: "base",
    payload: {
      txHash,
      walletSig,
      nonce: baseEntry.extra.sign_message_template.split(":")[1],
    },
  })).toString("base64");

  const verdict = await fetch(URL, {
    method: "POST",
    headers: { "Content-Type": "application/json", "X-PAYMENT": xPayment },
    body: JSON.stringify({ url: target }),
  });
  return verdict.json();
}

Cliente completo — Python en Solana

El mismo flujo en Solana con solana-py. La vinculación del memo reemplaza el paso de firma off-chain.

import base64, json, httpx
from solana.rpc.api import Client
from solders.keypair import Keypair
from solders.transaction import Transaction
from solders.pubkey import Pubkey
from spl.token.instructions import transfer_checked, TransferCheckedParams
from spl.token.constants import TOKEN_PROGRAM_ID

USDC_MINT = Pubkey.from_string("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v")
RPC_URL   = "https://api.mainnet-beta.solana.com"
rpc       = Client(RPC_URL)
kp        = Keypair.from_base58_string(os.environ["SOLANA_SECRET"])

def detect(target: str) -> dict:
    # 1. Challenge
    r = httpx.post("https://api.safebrowz.com/v1/detect",
                   json={"url": target})
    if r.status_code != 402:
        return r.json()
    sol_entry = next(a for a in r.json()["accepts"] if a["network"] == "solana")

    # 2. Build USDC transferChecked + spl-memo binding the nonce
    memo = sol_entry["extra"]["memo_template"]   # "safebrowz:<nonce>"
    tx   = build_usdc_transfer_with_memo(
        payer=kp.pubkey(),
        receiver=Pubkey.from_string(sol_entry["payTo"]),
        amount_atomic=int(sol_entry["maxAmountRequired"]),
        memo_text=memo,
    )
    tx.sign([kp], rpc.get_latest_blockhash().value.blockhash)
    tx_sig = rpc.send_transaction(tx).value

    # 3. Retry with X-PAYMENT
    x_payment = base64.b64encode(json.dumps({
        "x402Version": 1, "scheme": "exact", "network": "solana",
        "payload": {"txSignature": str(tx_sig), "nonce": memo.split(":")[1]},
    }).encode()).decode()

    return httpx.post(
        "https://api.safebrowz.com/v1/detect",
        headers={"X-PAYMENT": x_payment},
        json={"url": target},
    ).json()

Clientes sin configuración con agentcash

Si no quieres implementar tu propio flujo de pago, el ecosistema x402 ya incluye clientes CLI y de librería que manejan todo el proceso automáticamente:

npx agentcash fetch https://api.safebrowz.com/v1/detect \
  --body '{"url":"https://trezor-support.com"}' \
  --network solana

El CLI detecta el 402, firma y transmite el pago USDC desde una billetera configurada, reintenta con el encabezado X-PAYMENT compatible con la especificación, e imprime el veredicto. Una sola línea.

Descubrimiento nativo para agentes

Más allá del endpoint en sí, publicamos todos los artefactos que un agente IA necesita para descubrir, comprender e integrarse con la API sin un humano en el ciclo:

Artefacto	Ruta	Consumido por
Especificación OpenAPI 3.1	/v1/openapi.json	Generadores de SDK, Postman, ChatGPT Actions
Documento de descubrimiento x402	/.well-known/x402	x402scan, Coinbase Bazaar, agentcash
Archivo de skill de agente	/safebrowz-api.skill.md	Skills de Claude, uso de herramientas GPT, LangChain, servidores MCP
Manifiesto de plugin IA	/.well-known/ai-plugin.json	Plugins GPT heredados, conectores ChatGPT
llms.txt	/api-llms.txt	Rastreadores de recuperación estilo ChatGPT

Un framework de agente puede leer cualquiera de estos, construir una definición de herramienta y comenzar a pagar escaneos dentro de un único turno de conversación. Ese es el estándar para "listo para agentes" en 2026.

Por qué $0.001 y no más

Poner precio a una nueva API es una suposición hasta que llegan datos reales. Lo analizamos desde tres ángulos y los tres apuntaron al mismo número.

Ángulo de margen. El costo amortizado por escaneo (los aciertos de caché subvencionan las llamadas de contenido IA) se sitúa por debajo de $0.0002. A $0.001 mantenemos un margen saludable incluso con el comprador pagando su propio gas, que en Solana es un error de redondeo y en Base es un par de centavos.

Ángulo de mercado. Las APIs comerciales de seguridad de URL tienen precios de entre $2 y $10 por cada 1,000 llamadas, cuando puedes registrarte en ellas. $0.001 por llamada es $1 por 1,000. Pusimos el precio para ser la primera dependencia que un desarrollador utiliza, no la tercera.

Ángulo de economía de agentes. Un agente que envía 100 verificaciones de URL en una sesión a $0.001 cada una gasta $0.10 en total. Ese es el precio al que integrarnos se convierte en una decisión obvia para cualquier agente que no quiera ser el vector que drena a su usuario.

El comprador paga el gas, a propósito

El ecosistema x402 tiene dos escuelas sobre el gas. En el modelo liquidado por facilitador, el servidor (o un relayer compartido) envía la transferencia en cadena en nombre del comprador, absorbiendo el gas y recuperándolo del monto del pago. En el modelo el comprador paga el gas, el propio cliente transmite la transferencia. Elegimos el segundo.

A $0.001 por solicitud la matemática es implacable. El gas de Base para una transferencia USDC típica en condiciones normales es $0.002–0.005. Si lo absorbemos, el pago está en pérdidas antes de hacer ningún trabajo. Con volumen significativo estaríamos operando la API a pérdida.

El modelo de comprador-paga-gas invierte eso. El cliente ya está construyendo con un stack de billetera y transmitir es barato para ellos. Verificamos el resultado en cadena, devolvemos el veredicto y mantenemos el margen intacto. Para cada ruta de integración real (desarrollador con su propia billetera, agente prefinanciado por su operador, aplicación de billetera que ejecuta un proxy de backend) el gas no es un costo significativo.

Tenemos la ruta de relayer implementada y bloqueada detrás de un indicador de función. Por ahora, el comprador-paga-gas mantiene la economía limpia. Si la demanda empresarial cambia, podemos activar el indicador en 15 segundos.

Dos niveles: x402 para todos, claves Bearer para empresas

El endpoint público ejecuta x402 de pago por solicitud. Eso funciona perfectamente para integraciones de desarrollo puntuales, agentes IA que llaman un puñado de URLs por sesión, y cualquiera que quiera probar el producto sin un formulario de registro.

Para aplicaciones de billetera y plataformas con millones de usuarios finales detrás de un proxy de backend, la firma en cadena por llamada es impráctica. MetaMask no va a hacer que su extensión firme una transacción USDC cada vez que un usuario pasa el cursor sobre un enlace. Por eso existe un segundo nivel.

Las claves Bearer empresariales se aprovisionan bajo petición para integradores de alto volumen. Un token de larga duración de la forma sk_live_..., pasado como Authorization: Bearer sk_live_..., omite el flujo x402 por completo. Cada clave tiene su propio límite de tasa (negociado en el aprovisionamiento, típicamente entre 10,000 y 100,000 solicitudes por minuto) y su propio libro de uso. La facturación es mensual en USDC mediante suscripción fija.

Para quién es esto

• Frameworks de agentes IA — skills de Claude, uso de herramientas GPT, LangChain, servidores MCP. Cualquier agente que analice URLs desde la entrada del usuario o la web necesita una verificación de seguridad antes de hacer clic.
• Aplicaciones de billetera — snaps de MetaMask, extensiones de Phantom, Trust Wallet, Rainbow, Rabby. La seguridad de URL previa a la conexión detendría la mayoría de los drenajes de billetera que vemos cada mes.
• Frontends de dApp — cualquiera que integre enlaces de terceros, envíos de la comunidad, listados de marketplace. Un veredicto de seguridad de $0.001 por clic es más barato que un tweet enojado de un usuario drenado.
• Extensiones de navegador — herramientas de productividad y seguridad que quieren externalizar el razonamiento de URLs en lugar de ejecutar su propia detección.
• Motores de búsqueda agénticos — clones estilo Perplexity, navegadores estilo Arc, agentes de investigación personal. Cada enlace mostrado es un drenaje potencial si no se filtra.
• Bots de Telegram / Discord — herramientas de moderación de comunidades. Nosotros mismos enviamos uno en @SafeBrowzbot.

Qué viene a continuación

• Más cadenas — Arbitrum + Optimism para el tercer trimestre, Polygon cuando la demanda lo justifique. Mismo endpoint, misma respuesta, entradas adicionales en el array de accepts del 402.
• Escaneo en lote — POST /v1/detect/batch para flujos de trabajo que necesitan más de 50 URLs de una vez. Precio lineal, pequeño descuento por concurrencia.
• Nivel de streaming por webhook — para clientes empresariales que desean flujos de alertas en tiempo real en lugar de sondeo. Misma autenticación Bearer, WebSocket persistente, mayores límites de tasa.

También estamos listados en x402scan, el directorio del ecosistema para servicios habilitados con x402. A medida que más clientes (agentcash, Coinbase Bazaar, billeteras CDP) lleguen al mercado, el directorio se está convirtiendo en el equivalente nativo para agentes de un marketplace de APIs.

Pruébalo ahora

La demo en vivo está en safebrowz.com/api-docs. Conecta Phantom o MetaMask, escanea cualquier URL, ve el veredicto. La integración completa tarda menos de una hora incluso para alguien que nunca haya usado x402 antes, y solo pagas por lo que realmente usas.

Creemos que el endpoint de pago abierto va a ser la forma dominante de comercio máquina a máquina en dos años. Preferimos ser la capa de seguridad antiPhishing que llega primero que la que llega tarde. Si estás construyendo algo que toca URLs o billeteras, pruébalo y cuéntanos qué falla.