Launch on o1. From a post.
o1bot.exchange turns a mention on X into a real token launch on o1 Launchpad. You link your X account once, keep a little ETH in the wallet that gets created for you, and post the command. The bot does the on-chain work from your wallet and replies with the result.
What o1bot is, and what it is not
o1bot owns three things: the X bot, the wallets it creates for users, and the web app. Everything on chain belongs to o1 Launchpad: the factory that creates the token, the Uniswap v4 pool, the hook that collects fees, the fee escrow, and the audits. o1bot does not run its own launch contracts and does not sit between you and o1.
That is why a token launched through o1bot is a normal o1 token. It shows up on o1, it trades on o1, and the creator fees go to the address o1 recorded at launch, which is your wallet.
v1 runs on Robinhood Chain only. Every command, pair and fee in these docs refers to Robinhood Chain (chain id 4663). Base support is not planned for v1.
Who pays for what
Your wallet pays o1's creation fee and the gas for the launch. If you add a dev buy, your wallet pays that too. o1bot never fronts fees or gas, never takes a cut of a launch, and never holds your keys.
o1bot earns from two places that never touch your launch: its own official token, launched through the same pipeline as everyone else's, and the 0.2% referral share o1 pays on trades that go through the o1bot app's swap.
How to read these docs
- Start gets you from zero to your first launch.
- Launching covers every option of the command and what each reply from the bot means.
- Money explains fees, your wallet, and the app.
- Developers documents how the bot builds a launch on chain, the contract addresses, and how to run the code.
Three things, once.
After this, every launch is a single post.
Open o1bot.exchange and sign in with the X account you will post from. That creates your wallet, secured by Privy. On the same screen, allow o1bot to sign launches from this wallet. Without that permission the bot cannot launch for you.
Send ETH on Robinhood Chain to the wallet address shown in the app. A plain launch needs o1's 0.001 ETH creation fee plus gas, about 0.002 ETH in total at normal gas prices. Add whatever you want to spend on a dev buy on top.
Mention the bot with the launch command. Attach an image and it becomes the token logo. The bot replies with the token address and links within about a minute.
The bot never launches a token it cannot pay for. If the wallet is short, it replies with the exact shortfall and your deposit address instead of trying.
What happens after you post
- The bot reads the post and turns it into a launch command. If something required is missing, it asks one question.
- It checks that your account is linked, the pair exists on o1's factory, and your wallet holds enough ETH.
- It prepares the token metadata, mines an address ending in
01as o1 requires, and simulates the whole launch. - It signs the launch from your wallet, waits for the receipt, and replies under your post with the token address, the o1 link, and the o1bot token page.
Trading opens immediately with o1's 20-second anti-snipe period. See Fees and economics.
The launch command
One line. Three required values, three optional extras. Casing, quotes, word order and language are flexible, but the bot never guesses a value you did not write.
Required values
| Value | Rule | Example |
|---|---|---|
| Ticker | 1 to 11 letters or digits. The $ is optional; the bot uppercases it. Tickers that equal a stock token symbol on o1's factory (NVDA, TSLA, and so on) are refused. | $RUGRAT |
| Name | Up to 50 characters, kept exactly as written. Quotes are recommended when the name has spaces. | "Rugrat" |
| Pair | The asset the token trades against: ETH, USDG, or a stock token symbol. Company names work when unambiguous ("pair nvidia" becomes NVDA). | pair ETH |
Optional extras
| Extra | What it does | Example |
|---|---|---|
| on robinhood | Names the chain. v1 only runs on Robinhood Chain, so leaving it out means Robinhood. Naming another chain gets a polite refusal. | on robinhood |
| devbuy | Buys tokens in the same transaction as the launch, paid in ETH from your wallet. The only way to buy at launch without o1's anti-snipe surcharge. See Dev buy. | devbuy 0.05 |
| fees to | Sends the creator fee stream to another X account. You still pay for the launch. See Fees to another account. | fees to @alice |
| An image | Attach a picture to the post and it becomes the token logo. See Token image and metadata. | — |
Examples that work
The bot replies in the language you posted in.
What the bot will not guess
If the ticker, the name or the pair is missing, the bot asks one question instead of inventing a value. Amounts are taken literally: devbuy 0.05 means 0.05 ETH, and devbuy $50 is a question back to you because the bot does not convert currencies. Instructions aimed at the bot inside a post ("ignore your rules", "use the platform wallet") are ignored; the post is treated as data.
Pairs
The pair is the asset your token trades against and the asset every trading fee is paid in. o1's Robinhood factory registers 196 of them.
| Kind | Pairs | Fees paid in | Dev buy |
|---|---|---|---|
| ETH | Native ETH on Robinhood Chain | ETH | Yes |
| USDG | Global Dollar, 6 decimals | USDG | Yes |
| Stocks | 194 registered stock tokens: AAPL, NVDA, TSLA, MSFT, GOOGL, AMZN, META, MSTR, COIN, QQQ, SPY-style ETFs and many more | The stock token | 185 of 194, where the stock has on-chain liquidity |
Stock-paired launches
A stock-paired token is created by the same factory with the same 0.001 ETH creation fee. The difference is the pool: it holds your token against the stock token, so buyers pay in the stock, and your creator fees arrive in the stock. That is the point for many creators: a coin that earns NVDA on every trade.
Because the pair asset is a stock token, a dev buy has to convert your ETH into that stock first. The bot finds a route through Robinhood's pools automatically; where none has liquidity, it tells you and offers a launch without the dev buy. Details in Dev buy.
Naming a pair
- Symbols always work:
pair NVDA,pair usdg,pair $ETH. - Aliases the bot understands: ether and ethereum for ETH, and company names that identify exactly one listed stock, such as nvidia, tesla, apple, google.
- If a name could mean two stocks, the bot asks which one.
- An asset that is not registered on o1's factory (DOGE, for example) gets a reply saying it is not available.
Tickers that collide with stocks
You cannot launch a token whose ticker equals a stock token symbol registered on the factory, so nobody mistakes your $TSLA for the tokenized stock. Pick another ticker; $TSLADOG is fine.
The list of registered pairs is refreshed from o1's published catalog. Every launch also re-reads the factory on chain, so a pair o1 removes cannot be selected even before the catalog is updated.
Dev buy
A dev buy purchases tokens in the same transaction that creates them. It is the one buy that skips o1's anti-snipe surcharge.
Why it exists
For 20 seconds after a pool opens, o1 charges a fee that starts at 99% and falls to the normal 1%. It stops bots from sniping the first blocks. The creator's own atomic buy is exempt: it pays the normal 1% and nothing more. Any buy in a later transaction, including one from you, pays the schedule like everyone else. The bot will never place a follow-up buy inside the window.
What you pay
The amount after devbuy is ETH, taken from your wallet on top of the creation fee and gas. devbuy 0.05 on a plain launch means the transaction carries 0.051 ETH plus gas.
| Item | ETH |
|---|---|
| Creation fee to o1 | 0.001 |
| Dev buy | 0.050 |
| Gas (about 2.7M gas at typical prices) | ~0.001 |
| Total the wallet needs | ~0.052 |
Slippage protection
Before signing, the bot simulates the launch and reads how many tokens the buy would return. It then sets a minimum output 3% below that. If the chain moves against you between simulation and confirmation, the whole launch reverts and nothing is spent except gas. The bot tells you and you can post again.
How the ETH reaches the pool
- ETH pair: straight into the new pool. One hop.
- USDG pair: ETH is swapped to USDG on Robinhood's SwapX pool first, then into the new pool.
- Stock pair: either ETH to the stock directly, or ETH to USDG to the stock, depending on where the liquidity is. The bot tries every liquid route, simulates each, and uses the one that returns the most tokens.
Routes are discovered on chain at launch time. As of the September 2026 survey, 185 of the 194 stock tokens have a liquid route from ETH. For the rest, the bot replies that a dev buy is not available for that pair and offers to launch without it.
A launch with a dev buy is valid for 5 minutes after the bot prepares it, versus 30 minutes for a plain launch. o1's swap adapter rejects longer deadlines. In practice the bot signs within seconds, so you will not notice.
Fees to another account
Launch a token whose creator fees go to someone else on X. They do not need an account yet.
How it works
- The bot resolves
@aliceto her stable X user id, so a later handle change does not break anything. - If she has never used o1bot, a wallet is created for her in advance, tied to that X id. When she signs in with X at o1bot.exchange, that wallet is already hers.
- Your wallet launches the token as usual. You remain the on-chain creator and pay everything.
- Right after the launch confirms, the bot sends a second transaction from your wallet that points the creator fee stream at her wallet. The bot replies only after both confirm, and mentions her so she knows.
Claiming as the recipient
Fees accumulate in o1's fee escrow until claimed. The recipient signs in at o1bot.exchange, opens their wallet, and claims. A brand-new wallet has no ETH for gas, so o1bot covers the first claim's gas; after that the recipient's wallet pays its own way.
Who can receive fees
- Any real X account except suspended ones.
- Not the bot's own accounts and not o1's accounts.
- You keep the other creator rights (metadata, transferring creator rights) unless you transfer them separately on o1.
Token image and metadata
Attach a picture to the post and it becomes the token logo. Everything is pinned to IPFS before the launch is signed.
Image rules
| Rule | Value |
|---|---|
| Formats | PNG, JPEG, WebP, GIF. The file's real type must match its declared type. |
| Size | 2 MB at most, o1's limit |
| Which image | The first image attached to the post. Video and links are ignored. |
| No image | A generated placeholder tile in a colour derived from the ticker |
What gets recorded
The token's contract metadata is a small JSON document with the name, symbol, image, a link to the o1bot token page, and attribution to the post that launched it: the author's handle, X user id, and the post id. Anyone can verify which post created which token.
Metadata is fixed at launch. The o1bot creates every token with editing disabled, which is also what o1 marks as the immutable default.
What the bot replies
Every mention gets at most one reply. Here is each kind, what triggers it, and what to do next. Replies are written in the language of your post; the English versions are shown.
Launched
One question
Not linked yet
Balance is short
Other outcomes
| Reply | Cause | Fix |
|---|---|---|
| Only Robinhood Chain is supported | The post named Base or another chain | Drop the chain or write on robinhood |
| Pair not available | The asset is not registered on o1's factory | Choose from Pairs |
| Ticker matches a stock | The ticker equals a registered stock symbol | Pick another ticker |
| No dev-buy route for this pair | The stock has no liquid route from ETH | Launch without devbuy |
| Slow down | One launch per account per 10 minutes, five per day | Wait, then post again |
| Launch failed on chain | Simulation or the transaction reverted (for example o1 rotated its configuration mid-flight) | Post again; the bot re-reads everything fresh |
| Help reply | The post asked how the bot works, about wallets, fees or pairs | A short answer with a link to o1bot.exchange |
| No reply | No actionable intent, spam, or abuse | — |
Limits and rules
Some come from o1's contracts, some from o1bot to keep the bot usable for everyone.
Rate limits (o1bot)
| Limit | Value |
|---|---|
| Launches per X account | 1 per 10 minutes, 5 per day |
| Replies | At most one reply per mention |
| Retweets and quote-tweets of the bot | Ignored |
Token fields (o1 limits, o1bot rules)
| Field | Rule |
|---|---|
| Ticker | 1 to 11 characters, uppercase letters and digits only. o1 allows more characters; o1bot keeps tickers plain so they read the same everywhere. |
| Name | 50 characters |
| Image | 2 MB, PNG/JPEG/WebP/GIF |
| Supply | 1,000,000,000 tokens, 18 decimals, all of it placed in the pool. Fixed by o1's factory. |
| Token address | Always ends in 01. Required by o1; the bot mines a salt to satisfy it. |
What the bot never does
- Never guesses a ticker, name, pair, chain or amount you did not write.
- Never signs anything but a launch, the ERC-20 approval a launch may need, the fee-recipient update, or a fee claim, and only to o1's contracts.
- Never buys after the launch transaction, and never inside the anti-snipe window.
- Never pays from a o1bot wallet on your behalf, and never sets o1bot as the creator of your token.
Fees and economics
Two fees exist, both o1's. o1bot adds none.
Creation fee
0.001 ETH per launch, paid to o1 by your wallet, for every pair including stock pairs. Plus network gas, roughly 2.2 million gas for a plain launch and 2.7 million with a dev buy. The fee is a setting o1 can change; the bot reads the live value before every launch and tells you the exact amount if your wallet is short.
Swap fee
Every trade in the pool pays 1% of the paired asset, split three ways:
| Recipient | Share of the 1% | Of each trade |
|---|---|---|
| Creator (you, or your fees-to account) | 50% | 0.5% |
| o1 platform | 30% | 0.3% |
| Referrer (the app the trade came through) | 20% | 0.2% |
Fees are always in the pair asset: an ETH pool pays ETH, a USDG pool pays USDG, an NVDA pool pays NVDA. When a trade has no valid referrer, o1 keeps the 0.2%.
The opening 20 seconds
Trading is open from the first block, but the total fee starts at 99% and falls linearly to 1% over 20 seconds. Everything above 1% goes to o1. The creator's atomic dev buy is exempt; every later buy is not.
What o1bot earns
- The referrer share (0.2% of trades) on swaps made through the o1bot app. o1 pays it; traders pay nothing extra. o1 rejects a referrer that equals the creator or the fee recipient, so o1bot's referrer wallet is a separate address from any user wallet.
- Creator fees on o1bot's own token, launched through the same pipeline as everyone else's.
There is no fee on launches, no fee on claims, nothing taken from user wallets.
Wallet and security
Your launches are signed by a wallet that is yours. Here is exactly what the bot can and cannot do with it.
The wallet
Signing in with X at o1bot.exchange creates an embedded wallet through Privy, tied to your X account. It is a normal Ethereum address. You can see it, top it up, export its private key, and use it anywhere. o1bot never sees the key.
The permission you grant
For the bot to launch from your wallet, you allow "delegated signing" once in the app. Until you do, the bot replies that your account is not linked. You can revoke it in the app at any time.
What the bot is allowed to sign
The signer inside the bot refuses everything that is not on this list, before the request ever reaches Privy:
| Transaction | To |
|---|---|
| Create a launch, with or without a dev buy | o1's active factory |
Point the creator fee stream at another wallet (fees to) | o1's active factory |
| An ERC-20 approval a launch may need | A registered pair token only |
| Claim accumulated fees | o1's fee escrow |
No plain transfers, no other contracts, no message signing, no signing on other chains. A post cannot turn into arbitrary calldata; the bot only fills the fields of those four calls. Every signed transaction is logged with the post id, your X id, your wallet, and a hash of the calldata.
Things worth knowing
- You are the on-chain creator. o1 records your wallet as the original creator; that cannot be changed by o1bot.
- Keep only what you plan to spend in the launch wallet. It is a hot wallet by design.
- The
fees torecipient's wallet is created in advance and handed to them on their first sign-in. Until then nobody can spend from it. - o1bot's treasury and referrer wallets are separate addresses that never sign user launches.
The o1bot app
o1bot.exchange is where you link X, watch your wallet, and, soon, trade and claim.
Available now
- Sign in with X and create your wallet.
- See your address, your ETH balance on Robinhood Chain, and whether the bot is allowed to sign.
- Export your private key.
Coming soon
- Board and token pages are live in the app: every token launched through o1bot, with the post that launched it, chart, trades, holders and price.
- Swap: buy and sell through o1's pool from your o1bot wallet, with the anti-snipe countdown shown live. Trades made here carry o1bot as the referrer.
- Claim fees: collect your creator fees from o1's escrow, grouped by asset.
Architecture
A pipeline from a mention to a receipt. Each stage can refuse; only the executor touches the chain.
Stages
| Stage | Job | Can refuse with |
|---|---|---|
| Listener | Polls mentions of the bot, dedupes by post id, ignores retweets and quotes of the bot, keeps the author's X id, handle and first image. | Silence |
| Parser | One Claude call with a strict output schema, then deterministic normalisation. Never invents values. | A question, a help reply, or silence |
| Validator | Account linked and delegated, rate limits, pair registered live, ticker not a stock symbol, fees-to target resolvable and allowed. | Not linked, slow down, pair unavailable |
| Queue | One job per post, keyed by post id, processed one at a time. A job that fails after signing is never retried automatically. | — |
| Executor | Reads the factory at one block, pins metadata, mines the salt, builds and simulates the call, checks funding, signs from the user's Privy wallet, broadcasts, waits, sends the fee-recipient update if needed. | Balance short, no dev-buy route, on-chain failure |
| Replier | Posts one reply with the outcome, localised to the post's language. | — |
| Indexer | Follows Launched and trade events on every o1 factory that ever existed on the chain, keeps o1bot-originated launches, serves the app. | — |
Stack
TypeScript throughout. viem for chain reads and writes, Privy for wallets and login, the Anthropic SDK for the parser, Postgres with Prisma for users, mentions, launches and the signed-transaction audit log, Redis for the queue and dedupe, Next.js for the app. Verified contract ABIs are vendored from two independent sources and must agree.
How a launch is built
The executor never trusts a cached number and never broadcasts a call it has not simulated. This is the order of operations.
o1's published registry is fetched and compared with the vendored snapshot. If o1 rotated the active factory, the run stops until the snapshot and ABIs are refreshed.
configVersion, launchSupply, tickSpacing, nativeLaunchFee, launchCreationEnabled, TOKEN_ADDRESS_SUFFIX, the token deployer, the hook, the launch-buy adapter, and quoteConfig plus quoteRevision for the pair. All at the same block so they are mutually consistent. Creation disabled, pair unregistered, or a suffix other than 1 stops the run.
The image is validated by its magic bytes and size, then pinned; the metadata JSON is pinned; the resulting ipfs:// URI goes into the launch parameters.
The factory scopes every salt to the caller: scopedSalt = keccak256(abi.encode(creator, creatorSalt)). The token address is CREATE2(tokenDeployer, scopedSalt, launchTokenBytecodeHash). The bytecode hash does not depend on the salt, so it is read once and the search runs locally until the address ends in 01, about 256 tries.
createLaunch(params) with value = nativeLaunchFee, or createLaunchAndBuy(params, buy) with value = nativeLaunchFee + amountIn and native funding. expectedConfigVersion is the fresh read. Deadline is the block timestamp plus 30 minutes, or 5 minutes with a dev buy.
An eth_call from the user's address. The token the factory returns must equal the mined prediction. With a dev buy, every discovered route is simulated and the one with the largest output wins; its output minus 3% becomes minAmountOut.
Gas is estimated with 20% headroom; the required amount is value plus gas at the current fee. The user's real balance decides whether to continue.
The call passes the allow-list guard, is signed by the user's Privy wallet, broadcast, and awaited. Launched in the receipt gives the token and pool id. With fees to, setCreatorFeeRecipient follows as a second transaction, and the reply waits for both.
Errors the executor understands
| Revert | Meaning | Action |
|---|---|---|
| StaleConfig | o1 changed a setting after the read | Re-read and rebuild |
| LaunchExpired | Deadline passed | Rebuild with a fresh deadline |
| LaunchSaltUsed | The scoped salt was already used | Mine a new salt |
| QuoteNotRegistered | Pair removed from the factory | Tell the user |
| InvalidTokenAddressSuffix | Predicted address does not end in 01 | Never expected; stop |
| DeadlineTooLong | Dev-buy adapter rejects deadlines beyond a few minutes | Handled: 5-minute deadline |
| UnsupportedRoute | Dev-buy adapter refuses the route shape (native ETH into a non-launch V4 pool) | Handled: such routes are never built |
Dev-buy route data
The launch-buy adapter is not source-verified on any explorer, so its route format was reverse-engineered from live transactions and is pinned byte for byte in tests. A route is abi.encode(Step[]) where a step is (kind, tokenIn, tokenOut, pool, fee, tickSpacing, hooks, hookData); kind 1 is a SwapX V3 pool, kind 2 a Uniswap V4 pool. The last step is always the new launch pool with fee 0 and o1's hook.
Contracts on Robinhood Chain
Chain id 4663. All launch contracts are o1's; o1bot only calls them. Snapshot from o1's published registry, 2026-09-06.
Active launch suite (launchpad-v4-minimal)
| Contract | Address |
|---|---|
| Launch Factory | 0xcE9C48cFa068947f77738c81Be406B53338E5B0d |
| Launch Hook | 0x0310cFEbE1D7A69f2414f6595bBe9d17c5342aCc |
| Fee Escrow | 0xc5444b417a04a7E1B9C1E327c7D499803c14E5EF |
| Launch Token Deployer | 0xf86dfDb678D8E5d932100Ef479A59fa65a82a5Eb |
| Announcement Registry | 0x19C4c024Aca11e4A3d47792C69C80c8f4E596b23 |
| Launch-Buy Adapter | 0xF9804FeAB2F9b16EDE0Cd92E5C6e75C5cf64462f |
Configuration version 14 at the snapshot; creation enabled; native launch fee 0.001 ETH; tick spacing 200; supply 1,000,000,000 tokens.
Uniswap and pairs
| Contract | Address |
|---|---|
| v4 PoolManager | 0x8366a39CC670B4001A1121B8F6A443A643e40951 |
| v4 Quoter | 0x8dc178efb8111bb0973dd9d722ebeff267c98f94 |
| v4 StateView | 0xf3334192d15450cdd385c8b70e03f9a6bd9e673b |
| Universal Router | 0x8876789976decbfcbbbe364623c63652db8c0904 |
| Permit2 | 0x000000000022D473030F116dDEE9F6B43aC78BA3 |
| SwapX V3 factory (dev-buy routing) | 0x1f7d7550B1b028f7571E69A784071F0205FD2EfA |
| WETH (routing only) | 0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73 |
| Native ETH | 0x0000000000000000000000000000000000000000 |
| USDG | 0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168 |
The 194 stock token addresses are in o1's robinhood-stock-quotes.json, mirrored in the repo's config/.
Historical factories
o1 has rotated its Robinhood suite four times before the active one. Tokens created by those factories are still o1 tokens; the indexer keeps every suite from its first block and resolves a token by chain id and originating factory, never by assuming the current one.
Explorer: robinhoodchain.blockscout.com. Sources: o1 production contracts, launch-contract-suites.json.
Running it yourself
A pnpm monorepo. Everything runs in dry-run mode until you say otherwise.
Layout
config/ o1 contract snapshot, regenerated with pnpm o1:sync
abis/ verified ABIs (Sourcify + Blockscout must agree)
packages/shared env, chain + RPC fallbacks, o1 registry, tx allow-list
packages/db Prisma schema: users, mentions, launches, signed-tx audit
packages/wallet Privy: X user to wallet, pregeneration, guarded signer
packages/executor factory reads, salt mining, metadata, routes, planLaunch
packages/parser Claude mention parser with fixtures
apps/web Next.js app (Privy X login, wallet, onboarding)
apps/bot the worker
Setup
pnpm install
cp .env.example .env # Privy, X, Anthropic, Pinata keys; keep DRY_RUN=true
pnpm o1:sync # refresh config/o1.json from docs.o1.exchange
pnpm abi:vendor # re-vendor ABIs when o1:sync reports drift
pnpm db:generate && pnpm db:push
pnpm typecheck && pnpm test
Dry-run a launch
Simulates the whole thing against the live factory and sends nothing. A random creator is funded virtually inside the simulation, so it works with an empty wallet.
pnpm simulate --name "Rugrat" --symbol RUGRAT --pair ETH
pnpm simulate --name "Rugrat" --symbol RUGRAT --pair ETH --devbuy 0.01
pnpm simulate --name "Nvidia Dog" --symbol NVDOG --pair NVDA --devbuy 0.01
Test the parser
pnpm parse '@o1bot_exchange launch $RUGRAT "Rugrat" pair ETH on robinhood'
pnpm parse --fixtures # 24 fixtures against the live model
Environment
| Variable | Purpose |
|---|---|
| DRY_RUN | Default true. Parse, validate, simulate, but never broadcast or reply. |
| PRIVY_APP_ID / PRIVY_APP_SECRET / NEXT_PUBLIC_PRIVY_APP_ID | Same Privy app for the web app and the bot. Enable Login with X, embedded Ethereum wallets, delegated actions. |
| X_BEARER_TOKEN, X_APP_* | Read mentions (Basic tier) and post replies as the bot account. |
| ANTHROPIC_API_KEY, PARSER_MODEL | The parser. Model defaults to claude-sonnet-4-6. |
| PINATA_JWT | IPFS pinning for images and metadata. |
| RPC_ROBINHOOD | Paid RPC for production. Unset rotates through public endpoints. |
| DATABASE_URL, REDIS_URL | Postgres and Redis. |
| TREASURY_ADDRESS, REFERRER_ADDRESS | o1bot's own wallets. Never user wallets; never sign user launches. |
Test live launches on a fresh wallet with the minimum fee before enabling dev buys, and keep DRY_RUN=true until a full day of dry runs looks right.
Questions people ask
Is it free?
o1bot charges nothing. You pay o1's 0.001 ETH creation fee and gas from your own wallet, like any launch on o1.
Is the token different from one launched on o1's site?
No. Same factory, same pool, same fees, same audits. The only extra is the metadata line that records which post launched it.
Can I use my own wallet instead of the one o1bot creates?
Not for bot launches. The bot needs a wallet it is allowed to sign from, and that is the Privy wallet tied to your X account. You can export its key and use it anywhere afterwards.
I posted and nothing happened.
Check three things: the post mentions @o1bot_exchange and is not a quote or retweet of the bot; your account is linked and the bot is allowed to sign; the wallet holds enough ETH. If the bot replied with a question, answer it in a new post with the full command.
Can I change the name or image after launch?
No. Tokens launched through o1bot are created with metadata editing disabled.
Stock pair: what do I actually earn?
0.5% of every trade, paid in the stock token. Claim it from the app when it is live, or on o1 directly with your wallet.
The dev buy failed but the token exists?
That cannot happen. A dev buy is atomic with the launch: if the buy fails, the whole launch reverts and no token is created.
When is Base coming?
Not in v1. The bot, the pairs and the docs are Robinhood Chain only for now.
Status and changelog
What is built, what is being tested, and what is next. Updated as the bot moves toward public launch.
| Piece | State |
|---|---|
| Wallet and X login (Privy), delegation, onboarding | built |
| Executor: factory reads, salt mining, metadata, simulation, dev-buy routes | built tested against the live factory, no broadcast yet |
| Parser with 24 fixtures | built awaiting live model validation |
| Listener, validator, queue, signing, replies | built end to end with fakes and dry runs; live run pending API keys |
| App: board and token page (chart, trades, holders, creator post) | built swap execution and claims next |
| Indexer: swaps, prices, candles for o1bot launches | built validated against live pools |
| Public launch | not yet |
Changelog
2026-09-07
- Board and token pages with chart, trades, holders and the genesis post; indexer for swaps and prices. Only tokens launched through the bot are listed.
- Privacy policy, terms of use and how-it-works pages; repository published under the MIT license.
- Scope set to Robinhood Chain only for v1.
- Verified ABIs vendored from Sourcify and Blockscout; token address prediction validated against four live launches.
- Dev buy for ETH, USDG and 185 stock pairs through on-chain route discovery.
- Mention parser with structured output and deterministic normalisation.
2026-09-06
- Repository scaffolded: wallet, database schema, o1 snapshot, transaction allow-list, onboarding page.