AgentAddress Generator

Universal identity for AI agents on the internet

Download the skill for Vercel

Copied to clipboard

Works with Claude Code, Cursor, GitHub Copilot, Windsurf, Gemini CLI, and 40+ more agents.

AgentAddress is an open-source agent identification system: a unique, verifiable identity that works across any website that accepts AgentAddress authentication.

This tool runs locally in your browser. We don't store anything -- your recovery phrase and secret key never leave your device.

Repo: github.com/Apoth3osis-ai/agent-address

Using AgentAddress with AgentPMT credits and workflows: /autonomous-agents

Programmatic no-auth endpoint for agents: POST https://www.agentpmt.com/api/external/agentaddress

Click Generate New Agent Address to create a new identity.

Works on all EVM-compatible chains

EthereumBaseArbitrumOptimismPolygonBNB ChainAvalanchezkSyncLineaScrollBlastMantleFantomGnosisCronosCeloMoonbeamHarmonyZoraMetisAuroraTaikoSeiSepoliaHoleskyBase SepoliaArbitrum SepoliaOP Sepolia+30 more

Code Examples

Generate a new agent identity via the no-auth API endpoint. No dependencies, no authentication needed — just fetch.

const API_BASE_URL = "https://www.agentpmt.com";

// Call the no-auth API endpoint — no dependencies required
const resp = await fetch(`${API_BASE_URL}/api/external/agentaddress`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
});
const { data: agent } = await resp.json();

console.log("Agent Address:", agent.evmAddress);       // 0x... public address
console.log("Private Key:",  agent.evmPrivateKey);     // 0x... keep secret
console.log("Recovery:",     agent.mnemonic);          // 12-word phrase

// Store evmPrivateKey and mnemonic securely — this is your agent's identity.
// The address is the login, the private key proves ownership.

Purchase AgentPMT credits using the x402 payment protocol with an EIP-3009 `TransferWithAuthorization` signature.

Step 1: Set up your agent and imports

Load your agent's private key and configure the supported chains.

import { randomBytes, randomUUID } from "node:crypto";
import { createPublicClient, createWalletClient, http, parseAbi } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base, baseSepolia, arbitrum, optimism, polygon, avalanche } from "viem/chains";

const API_BASE_URL = "https://www.agentpmt.com";

const SUPPORTED_CHAINS = {
  8453:  { chain: base,        rpcEnv: "BASE_RPC_URL" },
  84532: { chain: baseSepolia, rpcEnv: "BASE_RPC_URL" },
  42161: { chain: arbitrum,    rpcEnv: "ARBITRUM_RPC_URL" },
  10:    { chain: optimism,    rpcEnv: "OPTIMISM_RPC_URL" },
  137:   { chain: polygon,     rpcEnv: "POLYGON_RPC_URL" },
  43114: { chain: avalanche,   rpcEnv: "AVALANCHE_RPC_URL" },
};

const AGENT_KEY = "0x<your_agent_private_key>";
const account = privateKeyToAccount(AGENT_KEY);
const desiredCredits = 500; // 500 credits = $5 USD

Step 2: Request payment requirements

POST to the credits endpoint. The server responds with HTTP 402 and a PAYMENT-REQUIRED header telling your agent how much to pay and where.

const purchaseInit = await fetch(
  `${API_BASE_URL}/api/external/credits/purchase`,
  {
    method: "POST",
    headers: { "Content-Type": "application/json", Accept: "application/json" },
    body: JSON.stringify({
      wallet_address: account.address,
      credits: desiredCredits,
      payment_method: "x402",
    }),
  },
);
// Server returns 402 with payment instructions
if (purchaseInit.status !== 402) {
  throw new Error(`Expected 402, got ${purchaseInit.status}`);
}

Step 3: Parse the payment instructions

Decode the base64 PAYMENT-REQUIRED header to get the token address, amount, destination, and chain.

const header = purchaseInit.headers.get("PAYMENT-REQUIRED");
const paymentRequired = JSON.parse(
  Buffer.from(header, "base64").toString("utf8"),
);

const acceptance = paymentRequired.accepts[0];
// acceptance = { network, amount, asset (USDC address), payTo }

const chainId = Number(acceptance.network.replace("eip155:", ""));
const { chain } = SUPPORTED_CHAINS[chainId];
const rpcUrl = process.env[SUPPORTED_CHAINS[chainId].rpcEnv];

Step 4: Read the USDC contract info

Query the token contract for its name and version — needed to build the EIP-712 signature domain.

const publicClient = createPublicClient({ chain, transport: http(rpcUrl) });
const walletClient = createWalletClient({ account, chain, transport: http(rpcUrl) });

const usdcAbi = parseAbi([
  "function name() view returns (string)",
  "function version() view returns (string)",
]);

const [name, version] = await Promise.all([
  publicClient.readContract({ address: acceptance.asset, abi: usdcAbi, functionName: "name" }),
  publicClient.readContract({ address: acceptance.asset, abi: usdcAbi, functionName: "version" }),
]);

Step 5: Sign the USDC transfer authorization

Sign an EIP-3009 TransferWithAuthorization — this authorizes the server to pull USDC from your agent's wallet without a separate approval transaction.

const validAfter = 0n;
const validBefore = BigInt(Math.floor(Date.now() / 1000) + 30 * 60);
const nonce = `0x${randomBytes(32).toString("hex")}`;
const amount = BigInt(acceptance.amount);

const signature = await walletClient.signTypedData({
  account,
  domain: { name, version, chainId, verifyingContract: acceptance.asset },
  primaryType: "TransferWithAuthorization",
  types: {
    TransferWithAuthorization: [
      { name: "from", type: "address" },
      { name: "to", type: "address" },
      { name: "value", type: "uint256" },
      { name: "validAfter", type: "uint256" },
      { name: "validBefore", type: "uint256" },
      { name: "nonce", type: "bytes32" },
    ],
  },
  message: {
    from: account.address,
    to: acceptance.payTo,
    value: amount,
    validAfter,
    validBefore,
    nonce,
  },
});

Step 6: Submit the signed payment

Send the signature back as a PAYMENT-SIGNATURE header. The server executes the transfer and credits your agent's account.

const paymentHeader = Buffer.from(
  JSON.stringify({
    x402Version: 2,
    scheme: "exact",
    network: acceptance.network,
    payload: {
      signature,
      authorization: {
        from: account.address,
        to: acceptance.payTo,
        value: acceptance.amount,
        validAfter: validAfter.toString(),
        validBefore: validBefore.toString(),
        nonce,
      },
    },
  }),
).toString("base64");

const purchaseResp = await fetch(
  `${API_BASE_URL}/api/external/credits/purchase`,
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Accept: "application/json",
      "PAYMENT-SIGNATURE": paymentHeader,
    },
    body: JSON.stringify({
      wallet_address: account.address,
      credits: desiredCredits,
      payment_method: "x402",
      request_id: `purchase-${randomUUID()}`,
    }),
  },
);
const result = await purchaseResp.json();
console.log("Credits purchased:", result);

Use your agent's private key to sign a session-based message and invoke an AgentPMT tool.

import { createHash, randomUUID } from "node:crypto";
import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

const API_BASE_URL = "https://www.agentpmt.com";

// Your agent credentials (from step 1)
const AGENT_KEY = "0x<your_agent_private_key>" as `0x${string}`;
const account = privateKeyToAccount(AGENT_KEY);

const walletClient = createWalletClient({
  account,
  chain: base,
  transport: http(process.env.BASE_RPC_URL as string),
});

// Helper: deterministic JSON for payload hashing
function canonicalize(value: unknown): unknown {
  if (Array.isArray(value)) return value.map(canonicalize);
  if (value && typeof value === "object") {
    return Object.fromEntries(
      Object.keys(value as Record<string, unknown>)
        .sort()
        .map((k) => [k, canonicalize((value as Record<string, unknown>)[k])]),
    );
  }
  return value;
}
function canonicalJson(value: unknown): string {
  return JSON.stringify(canonicalize(value));
}

// Step 1: Get a session nonce
const sessionResp = await fetch(`${API_BASE_URL}/api/external/auth/session`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ wallet_address: account.address }),
});
const { session_nonce: sessionNonce } = await sessionResp.json();

// Step 2: Build and sign the invocation message
const productId = "<productId>";
const parameters = { action: "get_instructions" };
const payloadHash = createHash("sha256")
  .update(canonicalJson(parameters))
  .digest("hex");
const requestId = `invoke-${randomUUID()}`;

const signMessage = [
  "agentpmt-external",
  `wallet:${account.address.toLowerCase()}`,
  `session:${sessionNonce}`,
  `request:${requestId}`,
  "action:invoke",
  `product:${productId}`,
  `payload:${payloadHash}`,
].join("\n");

const signature = await walletClient.signMessage({
  account,
  message: signMessage,
});

// Step 3: Invoke the tool
const invokeResp = await fetch(
  `${API_BASE_URL}/api/external/tools/${productId}/invoke`,
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      wallet_address: account.address,
      session_nonce: sessionNonce,
      request_id: requestId,
      signature,
      parameters,
    }),
  },
);
const result = await invokeResp.json();
console.log("Tool result:", result);

How Agent Addresses Work

Your Agent's Login

An AgentAddress is your agent's identity on AgentPMT and any service that supports AgentAddress authentication. Instead of a username and password, your agent signs messages with its private key to prove who it is. The wallet address is the login -- no emails, no passwords, no API keys to rotate. Any agent that holds the private key can authenticate as that address.

Credits & Purchases Linked to the Wallet

Everything your agent does on AgentPMT is tied to its wallet address. When your agent buys credits, invokes a tool, or subscribes to a workflow, the transaction is recorded against that address. Credit balances, purchase history, and usage analytics all live under the same address -- one identity, one ledger. If you generate a new address, it starts with a fresh balance; if you reuse the same private key, your agent picks up right where it left off.

Fund It with Crypto & Stablecoins

Because your agent's address is a standard EVM wallet, you can send cryptocurrency or stablecoins directly to it from any wallet or exchange. Send USDC, USDT, ETH, or any ERC-20 token on any supported chain -- the address works the same way across Ethereum, Base, Arbitrum, Optimism, Polygon, and every other EVM network listed below.

To buy AgentPMT credits autonomously, your agent uses the x402 payment protocol: it signs an EIP-3009 TransferWithAuthorization to pay with USDC directly from its wallet -- no bridges, no approvals, no human in the loop. Just fund the address and let your agent pay for what it needs.