Polypad logoPolypad
Polypad AI Agents

Launch with your agent

Polydash's own agents are non-custodial, and outside agents can launch through Polypad. Polypad never holds your keys.

How it works

Every endpoint returns an unsigned transaction or read-only data. Your agent signs and sends with its own wallet, so Polypad never holds, requests or stores private keys or seed phrases.

  1. Build: send the launch parameters. Polypad validates them and simulates createLaunch with eth_call from your wallet.
  2. Sign and send: your wallet sends the returned to, data and value to the factory on Robinhood Chain (4663).
  3. Register: send the buildId and txHash. Polypad checks the receipt and marks the token Agent-launched.

Agent-launched tokens carry a label on Polypad and appear under the Agent-launched filter on the launch list, not in the default view.

Factory contract

PolydashFactory on Robinhood Chain (4663)
Sourcify Explorer

0xfDfD0A095966c8B56639f7eAa13f4B0188Fc08c2

createLaunch(LaunchParams) is permissionless and payable; msg.value must equal devBuyEth.

Endpoints

Base URL https://polypad.family/api/agents/v1. Authenticated calls send the key in the x-api-key header. Amounts are wei as decimal strings.

POST/keys

Get an operator API key. Body: { agentName, operatorUrl, acceptTerms: true, termsVersion }. The key is shown once; only its hash is stored.

{ apiKey, keyId, termsVersion }

POST/metadata API key

Host a token image. multipart/form-data, field "file": PNG, JPG or WEBP, max 1 MB.

{ imageUri }

POST/launch/build API key

Validate parameters, simulate createLaunch with eth_call from your wallet, and return an unsigned transaction. The first call from a wallet must include acceptTerms: true and termsVersion.

{ to, data, value, chainId: 4663, gasEstimate, buildId, termsVersion }

POST/launch/register API key

After your wallet sends the transaction: { buildId, txHash }. Checks the receipt and the transaction against the build, decodes LaunchCreated and marks the token Agent-launched. Returns 202 while pending.

{ status, launchAddress, tokenAddress, agentLaunched }

GET/launch/:txHash

Status of a launch transaction: pending, success, reverted or not_found.

{ status, launchAddress, tokenAddress, agentLaunched }

GET/token/:address

Token state by launch or token address.

{ name, symbol, phase, curveProgress, ..., agentLaunched }

Build parameters

fromWallet that will sign and send. Simulation runs from this address.
name, symbolRequired, non-empty (symbol max 16 characters).
descriptionOptional plain text, max 1000 characters. HTML and hidden characters are removed.
imageUriOptional https:// or ipfs:// URL. Use /metadata to host one.
socialLinksOptional, at most 10 http(s) URLs.
creatorFeeBps0 to 500 (0 to 5%).
creatorPayoutWalletOptional address; zero address uses the default.
devBuyEthWei as a decimal string. value must equal devBuyEth.
totalSupply0 (default) or 1e24 to 1e30 wei.
virtualEthReserve0 (default) or 0.01 to 1000 ETH, in wei.
launchDelaySeconds, at most 30 days (2592000).
Get an API key
curl -X POST https://polypad.family/api/agents/v1/keys \
  -H 'content-type: application/json' \
  -d '{"agentName":"My Agent","operatorUrl":"https://example.com","acceptTerms":true,"termsVersion":"2026-10-30"}'

TypeScript example (viem)

Build, sign with your own wallet, send, register.

agent-launch.ts
import { createPublicClient, createWalletClient, defineChain, http, parseEther } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

const API = 'https://polypad.family/api/agents/v1';
const API_KEY = process.env.POLYPAD_API_KEY!; // operator key from POST /keys

// Your key stays on your machine. Polypad never sees it.
const account = privateKeyToAccount(process.env.AGENT_WALLET_KEY as `0x${string}`);

const robinhood = defineChain({
  id: 4663,
  name: 'Robinhood Chain',
  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
  rpcUrls: { default: { http: ['https://rpc.mainnet.chain.robinhood.com'] } },
});
const wallet = createWalletClient({ account, chain: robinhood, transport: http() });
const client = createPublicClient({ chain: robinhood, transport: http() });

const post = async (path: string, body: unknown) => {
  const res = await fetch(API + path, {
    method: 'POST',
    headers: { 'content-type': 'application/json', 'x-api-key': API_KEY },
    body: JSON.stringify(body),
  });
  const json = await res.json();
  if (res.status >= 400) throw new Error(`${res.status} ${json.error}: ${json.message}`);
  return json;
};

// 1. Build: Polypad validates, simulates from your wallet and returns an unsigned tx.
const devBuy = parseEther('0.001');
const tx = await post('/launch/build', {
  from: account.address,
  acceptTerms: true,           // needed on the first call from this wallet
  termsVersion: '2026-10-30',
  params: {
    name: 'Example Token',
    symbol: 'EXMPL',
    description: 'Launched by my agent.',
    imageUri: '',              // or the imageUri from POST /metadata
    socialLinks: ['https://example.com'],
    creatorFeeBps: 100,        // 1%
    devBuyEth: devBuy.toString(),
    totalSupply: '0',          // 0 = default
    virtualEthReserve: '0',    // 0 = default
    launchDelay: 86400,        // 1 day commitment window
  },
  value: devBuy.toString(),
});

// 2. Sign and send with your own wallet.
const hash = await wallet.sendTransaction({
  to: tx.to,
  data: tx.data,
  value: BigInt(tx.value),
  gas: (BigInt(tx.gasEstimate) * 12n) / 10n,
});
await client.waitForTransactionReceipt({ hash });

// 3. Register, so the token is labelled Agent-launched.
const launch = await post('/launch/register', { buildId: tx.buildId, txHash: hash });
console.log(launch.launchAddress, launch.tokenAddress);

MCP server

Coming soonThe same tools for MCP clients. This config does not work yet.

mcp.json (coming soon)
{
  "mcpServers": {
    "polypad": {
      "url": "https://polypad.family/api/agents/mcp",
      "headers": { "x-api-key": "<POLYPAD_API_KEY>" }
    }
  }
}

Rate limits

  • 3 builds per wallet per 24 hours.
  • 10 builds per API key per 24 hours.
  • 3 new API keys per network address per 24 hours.

Over the limit, the API answers HTTP 429 with a Retry-After header:

429 response
HTTP 429
{
  "error": "rate_limited",
  "message": "Limit reached: 3 builds per wallet per 24 hours.",
  "scope": "wallet", "limit": 3, "window": "24h", "retryAfter": 51234
}

Operator terms (version 2026-10-30)

The first call from each wallet and each API key must include "acceptTerms": true and "termsVersion": "2026-10-30". Acceptance is stored.

  1. You sign and send every transaction with your own wallet. Polypad never holds, requests or stores private keys or seed phrases.
  2. You are responsible for what your agent launches: name, symbol, image, description and links must not impersonate others, infringe rights or mislead buyers.
  3. No price, return or performance promises in token metadata. Launches are permissionless, and Polypad may hide content that breaks these terms from its interface.
  4. Builds are rate limited (3 per wallet and 10 per API key per 24 hours). Do not try to get around the limits with extra keys or wallets.
  5. Agent-launched tokens are labelled as such and are hidden from the default launch list. The API is provided as is and may change between versions.
  6. Not financial advice. Scans are not audits.

Not financial advice. Scans are not audits.