What you will set up

A public, payable wallet for an AI agent: a profile that anyone can open to find the agent's Base wallet address, confirm who runs it, and pay it in USDC. The wallet itself you may already have; this page is about making it public the right way, so the agent can receive from the open world rather than only from systems you control. By the end the agent has a shareable front door at wallet.blockchain0x.com/a/{slug}.

If the agent has no wallet yet, create it first with how-to-add-wallet-to-my-agent. The agent wallets product page is the broader reference.

What public means here

Be precise about what goes public, because the word worries people the first time. Public means the receiving address and the agent's profile are visible and shareable. It does not mean the keys are exposed, and it does not mean anyone can spend.

A wallet has two halves: an address, which is for receiving and is meant to be shared, and the keys that authorize spending, which must stay secret. Making a wallet public shares only the first half. Anyone with the address can send the agent USDC; no one with the address can take USDC out. The keys stay managed by the platform and are never part of the public surface. So a public wallet is exactly as safe to publish as a bank account number you give someone to pay you: useful for receiving, useless for stealing. Once that distinction is clear, making the wallet public is an obvious move for any agent that wants to be paid by people or agents it has not met.

It is worth saying what a public wallet is for, because not every agent needs one. An agent that only spends, paying APIs and other agents, does not need a public wallet; it needs a funded one. A public wallet matters when the agent should be findable and payable by others: when it sells a service, collects tips, or acts as a payee in an agent-to-agent exchange. If your agent is purely a buyer, skip this; if it is a seller or a counterparty, the public wallet is how the rest of the world reaches it.

Prerequisites

• A Blockchain0x account with the agent created, so it has a wallet and a profile.
• A sk_test_ API key for confirming the agent over the API.
• Access to a channel to verify (email, GitHub, or a domain).

Create the agent and find its profile

Creating the agent provisions both its wallet and its public profile. Confirm the agent and note its network:

import { createClient } from "@blockchain0x/node";

const client = createClient({ apiKey: process.env.B0X_API_KEY! });
const agent = await client.agents.get("agt_...");
console.log(agent.id, agent.name, agent.network);

The public profile lives at wallet.blockchain0x.com/a/{slug}. Open it; that page is the public wallet. It shows the agent's name, its Base wallet address, and any verification it has earned. This is the URL you will share, and the page a payer will look at before sending anything.

Make the profile payable and trustworthy

A bare profile is payable but not yet trustworthy, and the two are different things. Payable means the address is there. Trustworthy means a stranger has a reason to believe the address belongs to who it claims.

Set the agent's display name so the profile reads as a real service rather than an id. Then earn at least one verification badge, email is the fastest, and add GitHub or domain depending on whether your payers are developers or businesses. The full steps are in how-to-give-ai-agent-payment-identity. The order that matters: do not promote the public wallet widely until it has a name and at least one badge, because a profile that is just an anonymous address converts poorly and can read as a scam to the careful payers you most want.

Share the public wallet

Once the profile has a name and verification, share its URL where payers will encounter the agent: in the agent's own responses, in a directory or marketplace listing, in documentation, wherever a counterparty decides to pay. Share the profile URL, not the raw address, because the URL carries the address and the proof together. A payer who lands on the profile sees the address to send to and the verification that makes sending feel safe, in one place.

For machine payers, the same profile is what another agent inspects before paying yours. An agent evaluating whether to transact reads the verification on the profile the way a person would, so a well-set-up public wallet helps both human and agent payers say yes.

Monitor the public wallet

A public wallet receives from people you have not met, so watch it. The signal for an incoming payment is the payment.received webhook, which you verify with webhooks.verify the same way you verify any delivery.

import { webhooks } from "@blockchain0x/node";
// inside a raw-body webhook route:
const r = webhooks.verify({ headers: req.headers, rawBody: req.body, secret: process.env.B0X_WEBHOOK_SECRET! });
if (r.ok && r.eventType === "payment.received") notifyAndRecord(JSON.parse(req.body.toString("utf8")));

Two things are worth watching beyond the money itself. First, keep the verification current: if you let a verified domain lapse or rotate the GitHub account a badge points at, the public profile starts overstating what is proven, which quietly erodes the trust the public wallet runs on. Re-verify when a channel changes. Second, watch the rate and source of incoming payments the way you would watch any public endpoint; a public address is exposed to the open world, so unusual patterns are worth a look even though no one can spend from it. The wallet cannot be drained by being public, but its reputation is a living thing you maintain, not a one-time setup.

What stays private

The public surface is deliberately narrow: the name, the address, and the verification badges. Everything else stays private. The keys are never shown. Your spend limits are configured in the dashboard and are not part of the public profile. Your transaction history is yours to read through the API, not published on the profile. The public wallet exposes exactly what a payer needs to pay you and confirm you, and nothing about how you operate the agent or control its funds.

This is the right split. A payer needs to know where to send and whom they are paying; they do not need to know your budgets, your internal ids, or your operational setup. Keep the public surface to the payable front door and keep the controls behind it.

Common pitfalls

Three traps.

Confusing the address with the keys. Publishing the address is safe and is the whole point; the keys are never public. Do not avoid sharing the address out of a misplaced fear of exposure.

Promoting an unverified profile. A public wallet with no name and no badges converts poorly and looks risky. Earn at least the email badge before you share it widely.

Sharing the raw address instead of the profile. The address alone carries no trust. Share the profile URL so the payer gets the address and the verification together.

What to ship today

Open the agent's profile at wallet.blockchain0x.com/a/{slug}, set its name, earn the email badge, and share the profile URL. That is a public, payable, trustworthy wallet. Add GitHub or domain verification as you grow. For wallet creation see how-to-add-wallet-to-my-agent, and for the identity steps see how-to-give-ai-agent-payment-identity. Pricing is on the pricing page.