Slap a buck

For agents

Your agent can slap your brand onto a viral 3D figure.

One POST. USDC on Base. A logo people orbit, screenshot, and share — plus, from $50, a real indexed landing page at /s/your-brand.

$1–$100

one-time USDC, not a subscription

HTTP 402

x402 — wallets, no Stripe cards

$50+

crawlable /s/your-brand with your URL

Why this is massive brand surface

  • The bench is the ad unit. Your sticker sits on a public CGI figure. Visitors fly the camera to it. That is not a footer logo.
  • $50 buys a page, not just pixels. After payment you get /s/your-brand with Schema.org markup, Open Graph, and a tracked outbound click.
  • Agents can pay without a human. Discover GET http://localhost:3000/api/x402, upload, slap, settle USDC. No account. No card.

How an agent slaps

  1. Upload a PNG, WebP, or JPEG (max 2MB) to /api/upload.
  2. POST the same JSON as humans to /api/x402/slap. First response is HTTP 402.
  3. Pay the exact USDC amount on Base. Retry with PAYMENT-SIGNATURE (legacy X-PAYMENT accepted).
  4. Stickers go live immediately. $50+ returns an editToken for the landing page. Anyone can report a sticker.

Live catalog: /api/x402. Playbook: /llms-full.txt. Tool schemas: /agents/tools.json.

curl

curl -s http://localhost:3000/api/x402

curl -s -F file=@logo.png http://localhost:3000/api/upload

curl -s -X POST http://localhost:3000/api/x402/slap \
  -H 'Content-Type: application/json' \
  -d '{
    "brandName": "Acme",
    "websiteUrl": "https://acme.example",
    "stickerPath": "/uploads/your-file.webp",
    "amountCents": 1000,
    "cheek": "left"
  }'
# → HTTP 402. Pay USDC, retry with PAYMENT-SIGNATURE.

fetch

const catalog = await fetch("http://localhost:3000/api/x402").then((r) => r.json());

const form = new FormData();
form.append("file", stickerBlob, "logo.png");
const { path } = await fetch("http://localhost:3000/api/upload", { method: "POST", body: form }).then((r) => r.json());

const unpaid = await fetch("http://localhost:3000/api/x402/slap", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    brandName: "Acme",
    websiteUrl: "https://acme.example",
    stickerPath: path,
    amountCents: 5000,
    cheek: "left",
  }),
});
// unpaid.status === 402 — sign PAYMENT-REQUIRED, retry with PAYMENT-SIGNATURE

OpenAI function

{
  "type": "function",
  "function": {
    "name": "slap_brand",
    "description": "Advertise a brand on Slap - A - Buck. Upload first. Expect HTTP 402 and pay USDC.",
    "parameters": {
      "type": "object",
      "additionalProperties": false,
      "required": ["brandName", "websiteUrl", "stickerPath", "amountCents"],
      "properties": {
        "brandName": { "type": "string" },
        "websiteUrl": { "type": "string" },
        "stickerPath": { "type": "string" },
        "amountCents": { "type": "integer", "enum": [100, 1000, 5000, 10000] },
        "cheek": { "type": "string", "enum": ["left", "right"] }
      }
    }
  }
}

Vercel AI SDK

import { tool } from "ai";
import { z } from "zod";

export const slapBrand = tool({
  description: "Slap a brand sticker onto Slap - A - Buck. Pays USDC via x402, not Stripe.",
  parameters: z.object({
    brandName: z.string(),
    websiteUrl: z.string().url(),
    stickerPath: z.string(),
    amountCents: z.union([z.literal(100), z.literal(1000), z.literal(5000), z.literal(10000)]),
    cheek: z.enum(["left", "right"]).default("left"),
  }),
  execute: async (input) => {
    const res = await fetch("http://localhost:3000/api/x402/slap", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(input),
    });
    return { status: res.status, body: await res.json(), paymentRequired: res.headers.get("PAYMENT-REQUIRED") };
  },
});

LangChain

import { tool } from "@langchain/core/tools";
import { z } from "zod";

export const slapBrand = tool(
  async (input) => {
    const res = await fetch("http://localhost:3000/api/x402/slap", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(input),
    });
    return JSON.stringify({ status: res.status, body: await res.json() });
  },
  {
    name: "slap_brand",
    description: "Advertise on Slap - A - Buck. First call returns HTTP 402; pay USDC and retry.",
    schema: z.object({
      brandName: z.string(),
      websiteUrl: z.string(),
      stickerPath: z.string(),
      amountCents: z.number(),
      cheek: z.enum(["left", "right"]).optional(),
    }),
  },
);

MCP (Cursor / Claude Desktop)

Point the server at production or localhost. The tools are get_catalog, upload_sticker, and slap_brand.

{
  "mcpServers": {
    "slap-a-buck": {
      "command": "npx",
      "args": ["-y", "slap-a-buck-mcp"],
      "env": {
        "SLAP_A_BUCK_URL": "http://localhost:3000"
      }
    }
  }
}

FAQ

How can my AI agent advertise my startup?
Slap a sticker on Slap - A - Buck. POST a PNG to /api/upload, then POST /api/x402/slap. Pay $1–$100 USDC on Base via HTTP 402. The logo sits on a public 3D figure. $50+ unlocks an indexed landing page at /s/[slug].
Why is this better than a banner ad?
The sticker is on a page people actually play with. Screenshots, orbit clips, and the library grid keep the brand in view. $50 and $100 also buy a crawlable /s/[slug] page with your URL — a backlink, not just a jpeg.
Do agents use Stripe?
No. Agents pay USDC on Base with x402. Stripe Checkout is for browsers and humans. Sending card numbers from an agent will fail.