Launch a Token via the API

Create a token programmatically with a single request. POST /api/v2/factory/create returns an unsigned transaction — you sign it with your own wallet key and broadcast it. Chain Daddy never holds your key: the endpoint is a transaction builder, so a launch bot is just "build → sign → send."

Optionally, the same call can seed a DEX pool, lock the LP, and open trading atomically — token creation, liquidity, the lock, and the trading-enable all settle in the one transaction you sign, so the token is tradeable the moment it lands (no separate open-trading step, and no sniper window because the pool is funded in the same tx).

Authentication

Programmatic requests authenticate with an API key — see Authentication. Rate limits scale with your API tier.

Endpoint

POST /api/v2/factory/create
Content-Type: application/json

Request body

Field	Type	Notes
symbol	string	Ticker to launch (must be claimable on the target chain).
chains	array	[{ "chainId": 42161, "chainName": "arbitrum" }].
creatorAddress	string	The wallet that will sign + own the token.
supply	string	Total supply in human units (whole tokens). The backend scales by 10^decimals before building the tx — send "1000000000", not the base-unit value.
decimals	number	Token decimals (usually 18 on EVM).
metadata	object	{ "name": "...", "logoUrl": "...", "description": "..." } (optional).
mintable, burnable, renounceAtLaunch	bool	Token feature flags (optional).
maxSupply	string	Human-unit cap when mintable (optional).

Optional — launch with liquidity (EVM, one transaction):

Field	Type	Notes
liquidityPercent	number	1–100 — percent of supply paired into the pool.
nativeAmount	string	Native gas token for the pool, in wei.
dexRouter	string	A Uniswap-V2-compatible router for the chain — get valid options from GET /api/v2/factory/liquidity/options?chainId={id}.
lockerAddress	string	LP locker (optional) — from GET /api/v2/factory/lp-lock/options?chainId={id}. Omit to keep the LP.
lockDuration	number	Unix timestamp the LP unlocks (use a far-future value like 4294967295 for a permanent lock).

The endpoint computes the transaction's value for you (create fee + crown fee + nativeAmount + any locker fee), so you just sign and send.

Discover lockers for a chain

GET /api/v2/factory/lp-lock/options?chainId={id} lists the LP lockers available on a chain — for example ?chainId=4663 (Robinhood):

{
  "lockers": [
    { "provider": "Chain Daddy Locker", "address": "0x3443aBcED09A7697C8298D00916597f53C14b563", "isDefault": true }
  ]
}

Pass the address you want as lockerAddress. Availability is chain-dependent: UNCX on Ethereum, BNB Chain, Arbitrum, Base, and Polygon; the first-party, zero-fee Chain Daddy Locker (owner-less and non-upgradeable — no admin can touch a lock) on Robinhood, Avalanche, and the testnets. A chain with no locker returns { "lockers": [] } — omit lockerAddress and either keep the LP or burn it separately.

Response

{
  "transactions": [
    {
      "chainId": 42161,
      "chainName": "arbitrum",
      "transaction": { "to": "0x…factory", "data": "0x…", "value": "0x…" }
    }
  ]
}

Example — plain token (curl)

curl -sS -X POST https://api.chaindaddy.io/api/v2/factory/create \
  -H "Authorization: Bearer $CHAINDADDY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "symbol": "MYTKN",
    "chains": [{ "chainId": 42161, "chainName": "arbitrum" }],
    "creatorAddress": "0xYourWallet",
    "supply": "1000000000",
    "decimals": 18,
    "metadata": { "name": "My Token" },
    "renounceAtLaunch": true
  }'

Example — launch + LP + lock, then sign (viem)

import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { arbitrum } from 'viem/chains';

const account = privateKeyToAccount(process.env.LAUNCH_KEY as `0x${string}`);
const wallet = createWalletClient({ account, chain: arbitrum, transport: http() });

// 1. Build the unsigned launch tx (token + pool + permanent lock).
const res = await fetch('https://api.chaindaddy.io/api/v2/factory/create', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.CHAINDADDY_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    symbol: 'MYTKN',
    chains: [{ chainId: 42161, chainName: 'arbitrum' }],
    creatorAddress: account.address,
    supply: '1000000000',
    decimals: 18,
    metadata: { name: 'My Token' },
    renounceAtLaunch: true,
    // atomic liquidity:
    liquidityPercent: 50,
    nativeAmount: '1000000000000000000', // 1 ETH, in wei
    dexRouter: '0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24',
    lockDuration: 4294967295,            // permanent lock
    lockerAddress: '0x63F4B2C082B1E0bbA38874567E053800379bF8D7',
  }),
});
const { transactions } = await res.json();
const t = transactions[0].transaction;

// 2. Sign + broadcast with YOUR key. Chain Daddy never holds it.
const hash = await wallet.sendTransaction({
  to: t.to,
  data: t.data,
  value: BigInt(t.value),
});
console.log('launched:', hash);

Notes

• Fiat launches (PayPal/Coinbase) use a different flow (a server-signed payment receipt you redeem on-chain) — the wallet-pay /factory/create path above is the one to automate.
• Discover valid routers + lockers per chain at /factory/liquidity/options and /factory/lp-lock/options — availability is chain-dependent (see Liquidity).
• Pair a launch with a crown claim to register the ticker in the trustless registry — first-claim-wins per symbol, chain and token, with holder notifications on top. No other launch API registers the ticker at all.