# VortexDeployer docs — full text

> Every page of https://vortexdeployer.com/docs in one file, API pages first. Index: https://vortexdeployer.com/llms.txt

---

# API overview & keys

> Make an API key, find the API addresses and send your first call.

Source: https://vortexdeployer.com/docs/api/overview · Markdown: https://vortexdeployer.com/docs/api/overview.md

The VortexDeployer API lets your own code or an AI agent do what the app does: buy, sell, launch tokens, run tasks, read your wallets and PnL, and buy wallets from the Wallet Marketplace. Every call uses an [API key](https://vortexdeployer.com/docs/other/glossary#api-key) that you make in the app.

## Addresses

| What | Address |
|---|---|
| REST base | `https://evm.vortexdeployer.com/evm/api/v1` |
| Live updates | `wss://evm.vortexdeployer.com/evm/ws` |
| OpenAPI document | `https://evm.vortexdeployer.com/evm/api/v1/openapi.json` |
| MCP server | `https://evm.vortexdeployer.com/evm/api/v1/mcp` |
| Index of all addresses | `GET https://evm.vortexdeployer.com/evm/api/v1` |

The index and the [OpenAPI](https://vortexdeployer.com/docs/other/glossary#openapi) document need no key. Every other call needs one.

The API answers only at the address above. A key sent to any other host gets `404` with a message that names the right host.

## Make a key

1. Sign in at `https://vortexdeployer.com` and open **API** from your account menu. You can also go straight to `https://vortexdeployer.com/developers`.
2. On the **Keys** tab, click **Create key**.
3. Type a **Name**, for example "my trading bot". Tick the scopes the key needs. `read` is ticked for you.
4. Set **Limits** if you want them. They are all optional.
5. Type your **Account password** if the form asks for it. It asks when the key can trade or launch and your account has a password.
6. Click **Create key**, then **Copy key**.

![The Keys tab on the developer page. Key hints are blurred here.](https://vortexdeployer.com/docs/api/overview.png)

:::warning You see the key once
The app shows the full key only once. A lost key cannot be recovered. Revoke it and make a new one.
:::

A key looks like `vd_1a2b3c4d_…`. The 8 characters after `vd_` are its public prefix. The key's row shows them, so you can tell keys apart.

You can have up to 20 active keys. At 20, **Create key** is greyed out until you revoke one.

Keys are made, edited and revoked only in the app, while you are signed in. An API key cannot manage keys.

## Your first call

Send the key as a [bearer token](https://vortexdeployer.com/docs/other/glossary#bearer-token) in the `Authorization` header:

```bash
curl -s https://evm.vortexdeployer.com/evm/api/v1/me \
  -H "Authorization: Bearer vd_1a2b3c4d_…"
```

`GET /me` tells you who owns the key and what it may do:

```json
{
  "user": { "id": "1", "username": "yourname" },
  "key": {
    "id": "7",
    "name": "my trading bot",
    "prefix": "1a2b3c4d",
    "scopes": ["read", "trade"],
    "settings": { "maxSolPerTrade": 0.5, "dailySolCap": 5 },
    "restricted": true
  }
}
```

## How answers look

- Answers are JSON. Field names are camelCase, like `walletId`.
- Ids are strings of digits, like `"812"`.
- Fields that end in `Raw` or `Lamports` are strings in [base units](https://vortexdeployer.com/docs/other/glossary#base-units). `amountSol` is a plain number in SOL.
- An error has a stable `code`, a readable `error` and a `traceId`. Check `code` in your program; the `error` text can change. See [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors).
- Long lists take `?limit=` (1–500, default 200) and `?offset=`. The full count is in the `X-Total-Count` header.

## Scopes

A [scope](https://vortexdeployer.com/docs/other/glossary#scope) is a permission you give a key. Give each key only the scopes it needs.

| Scope | Lets the key |
|---|---|
| `read` | Read wallets, balances, portfolio, projects, tasks, events and PnL. Get quotes and checks. Browse the Wallet Marketplace and read your orders. Listen to task updates. |
| `trade` | Buy, sell, batch, convert, burn, lock and claim. Add, edit and delete wallets, groups, projects, tasks and KOLs. Order wallets from the [Wallet Marketplace](https://vortexdeployer.com/docs/api/marketplace). |
| `launch` | Launch tokens and upload token info (`POST /launch`, `POST /launch/metadata`). |
| `stream` | Listen to live trades, live PnL and live wallet balances. |

A call outside the key's scopes gets `403 insufficient_scope`.

## Limits on a key

Limits keep a key safe if it leaks or an agent makes a mistake. Set them under **Limits** in the key form. The API name of each setting is in brackets.

- **Max per buy** (`maxSolPerTrade`) — the largest single buy, in SOL or ETH. Up to 1,000,000. A bigger buy gets `403 over_trade_cap`.
- **Daily cap** (`dailySolCap`) — the total of real buys per chain per UTC day. Up to 10,000,000. A buy that would pass it gets `403 over_daily_cap`.
- **Default slippage** (`defaultSlippageBps`) — the [slippage](https://vortexdeployer.com/docs/other/glossary#slippage) used when a call sends none. 1–10000 [basis points](https://vortexdeployer.com/docs/other/glossary#basis-points).
- **IP allowlist** (`ipAllowlist`) — up to 32 IP addresses or ranges. Empty means any IP. A call from anywhere else gets `403 ip_not_allowed`.
- **Allowed wallet ids** (`allowedWalletIds`) — the only wallets the key may use. Other wallets get `403 wallet_not_allowed`. A private key in the body gets `403 private_key_not_allowed`.
- **Sandbox** (`sandbox`) — only [dry runs](https://vortexdeployer.com/docs/other/glossary#dry-run). A real call gets `403 sandbox_key`.

The daily cap counts a buy before it is sent. If the call is refused or nothing was sent, the amount is given back. If the buy was sent, it still counts, even if it failed on chain.

### Restricted keys

A key with a max per buy, a daily cap, a wallet list or sandbox on is a [restricted key](https://vortexdeployer.com/docs/other/glossary#restricted-key). `GET /me` shows `"restricted": true`. A restricted key:

- cannot create, edit, start or resume tasks, or send a mixer step;
- can send only dry-run launches and dry-run close-outs.

These calls get `403 key_restricted`. Use a separate key without limits for tasks.

## Edit, revoke and usage

- **Edit** — change the name, scopes or limits. Giving a key more power asks for your password again. Saving closes the key's open live connections, so your program must reconnect.
- **Revoke**, then **Confirm revoke** — the key stops working at once. It cannot be restored. It moves to the **Revoked keys** list.
- **Revoke all**, then **Revoke all keys** — every app and agent using your keys stops at once.
- **Usage** tab — calls per day, per key and per route, for 7, 30 or 90 days. It counts **OK**, **Refused (4xx)** and **Failed (5xx)** calls.
- **Feature requests** tab — ask for a missing endpoint, field or live topic.

:::danger A key moves real money
A key with `trade` or `launch` can spend the funds in your wallets. Buys, sells and batches are real unless you send `dryRun: true`. Launches are dry runs unless you send `dryRun: false`. Keep keys on your server, never in a web page, and add limits.
:::

## See also

- [Buy, sell & batches](https://vortexdeployer.com/docs/api/trading)
- [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors)
- [Build an agent on the API](https://vortexdeployer.com/docs/api/agents)
- [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run)

---

# Buy, sell & batches

> Buy and sell from one wallet or many, convert, burn and lock tokens, and claim creator fees from code.

Source: https://vortexdeployer.com/docs/api/trading · Markdown: https://vortexdeployer.com/docs/api/trading.md

These calls trade from your wallets. They need a key with the `trade` [scope](https://vortexdeployer.com/docs/other/glossary#scope), except the read-only checks noted below.

:::danger Buys, sells and batches are real by default
`POST /buy`, `POST /sell` and `POST /trade/batch` send real transactions unless you add `"dryRun": true`. Try every new call as a [dry run](https://vortexdeployer.com/docs/other/glossary#dry-run) first.
:::

## Pick the wallet

Every trade names one wallet, in one of two ways:

- `walletId` — the id of a wallet in your account, like `"812"`. List them with `GET /wallets`.
- `privateKey` — a wallet's [private key](https://vortexdeployer.com/docs/other/glossary#private-key). The API adds this wallet to your account and trades from it. A key limited to a wallet list cannot send private keys.

Send exactly one of the two.

## Buy

`POST /buy` spends the chain's coin to buy a token.

```bash
curl -s -X POST https://evm.vortexdeployer.com/evm/api/v1/buy \
  -H "Authorization: Bearer vd_…" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: buy-7xKX-0001" \
  -d '{ "mint": "7xKX…pump", "walletId": "812", "amountSol": 0.1, "dryRun": true }'
```

- `mint` — the token's [mint address](https://vortexdeployer.com/docs/other/glossary#mint-address). Base58 on Solana, `0x` plus 40 hex characters on an EVM chain.
- `amountSol` — how much to spend, as a number. It is SOL on Solana and ETH on an EVM chain. Up to 1,000,000.
- `amountRaw` — the same amount as a string in [base units](https://vortexdeployer.com/docs/other/glossary#base-units). Send `amountSol` or `amountRaw`, not both.
- `slippageBps` — the most the price may move against you, 1–10000 [basis points](https://vortexdeployer.com/docs/other/glossary#basis-points). Without it, the key's default slippage applies.
- `dryRun` — `true` checks the trade without sending it. Default `false`.
- `chain` — `solana` or an enabled EVM chain. Leave it out and the API picks it from the address.
- `poolAddress`, `dex` — trade through one pool. Leave them out and the API picks the route.
- `computeUnitLimit` (1–1,400,000), `computeUnitPriceMicroLamports` (0–100,000,000) — Solana fee settings. Leave them out for the defaults.

Unknown fields are refused with `400 validation_failed`.

## Sell

`POST /sell` takes the same body, with one of these amounts:

- `percentage` — the share of the wallet's balance to sell, above 0 and up to 100.
- `amountRaw` — the token amount as a string in base units.

```json
{ "mint": "7xKX…pump", "walletId": "812", "percentage": 50 }
```

A wallet that holds none of the token gets `422`. So does a percentage that rounds down to zero tokens.

## What a trade returns

```json
{
  "signature": "3BNE…L98",
  "confirmed": true,
  "dryRun": false,
  "walletId": "812",
  "mint": "7xKX…pump",
  "side": "buy",
  "poolAddress": "B8Ge…oH7V",
  "dex": "pump_swap",
  "amountIn": "100000000",
  "expectedOut": "3512000000",
  "minOut": "3336400000",
  "landedOut": "3509871234",
  "err": null
}
```

- `signature` — the [transaction signature](https://vortexdeployer.com/docs/other/glossary#transaction-signature), once sent. `null` on a dry run.
- `confirmed` — `true` once the chain confirmed it. `false` when nothing was sent.
- `amountIn`, `expectedOut`, `minOut`, `landedOut` — amounts in base units. `minOut` is the slippage floor. `landedOut` is what actually arrived, once known.
- `err` — why the send failed, or `null`.

## Batch: many wallets at once

`POST /trade/batch` buys or sells one token from many wallets in one call.

```json
{
  "mint": "7xKX…pump",
  "side": "buy",
  "walletIds": ["812", "813", "814"],
  "amountMode": { "type": "uniform", "amountRaw": "50000000" },
  "intervalMs": [500, 2000],
  "dryRun": true
}
```

- `walletIds` — at least one, no repeats.
- `amountMode` — how much each wallet trades, in base units. A buy spends the chain's coin; a sell spends the token.
  - `{ "type": "uniform", "amountRaw": "…" }` — the same amount for every wallet.
  - `{ "type": "individual", "amountsRaw": ["…", "…"] }` — one amount per wallet, in the same order as `walletIds`.
  - `{ "type": "token_percentage", "percentage": 25 }` — a share of each wallet's token balance.
- `intervalMs` — `[min, max]` milliseconds to wait between wallets. `max` must be at least `min`. Default no wait.
- `slippageBps`, `poolAddress`, `dex`, `chain`, `dryRun` — as for a single trade. `dryRun` defaults to `false`.

The answer lists one result per wallet:

```json
{ "results": [ { "walletId": "812", "signature": "…", "confirmed": true, "err": null, "expectedOut": "…", "landedOut": "…" } ] }
```

### Slow batches become a task

If the number of wallets times the `max` wait is over 60 seconds, the API does not wait. It starts a [task](https://vortexdeployer.com/docs/other/glossary#task) of type `batch`, labelled "API batch", and answers `202`:

```json
{ "taskId": "4321", "status": "started", "task": { "id": "4321", "type": "batch", "label": "API batch" } }
```

Follow it with `GET /tasks/4321/executions` or the live `tasks` topic. See [Tasks API](https://vortexdeployer.com/docs/api/tasks).

A slow buy batch needs real amounts (`uniform` or `individual`). A key with a max per buy or a daily cap must also send real amounts for any buy batch.

## Convert (Solana)

Convert swaps one asset in a wallet for another, like a leftover token into SOL. It works on Solana wallets only.

- `POST /convert/assets` (`read`) — `{ "walletIds": [...] }` lists what the wallets hold and where it can go.
- `POST /convert/quote` (`read`) — prices a conversion without sending it.
- `POST /convert` (`trade`) — converts.

The quote and convert body:

- `walletId`, `inputMint`, `outputMint` — the wallet and the two assets. They must differ. Native SOL is `So11111111111111111111111111111111111111112`; `wrapped-sol` means wrapped SOL (WSOL).
- `amountRaw` or `"all": true` — send one.
- `slippageBps` — 1–500, default 100.
- `maxPriceImpactBps` — 1–500, default 300.
- `minimumOutputRaw` — refuse if less would arrive.
- `dryRun` — default `true` here. Send `false` to convert for real.

A pair with no route gets `422`.

## Burn and lock

- `POST /tokens/burn` — a [burn](https://vortexdeployer.com/docs/other/glossary#burn) destroys tokens for good. Body: `walletId`, `mint`, `amount`, `amountType`, `chain`, `dryRun`. On an EVM chain, the tokens go to the dead address `0x…dEaD`.
- `POST /tokens/lock` — locks tokens until a date. Solana only. Same body, plus `unlockDays` (1/24 to 3650) or `unlockTimestamp` (Unix seconds), and an optional `name` (up to 64 characters).

Both default to `dryRun: true`.

`amount` is a string. What it means depends on `amountType`:

- `tokens` — a whole number of base units, like `"3500000000"` for 3.5 tokens with 9 decimals. It may not be more than the wallet holds. Do not send a decimal like `"1.5"`: the first check lets it through, but the burn or lock then fails.
- `percentage` — a whole number from `1` to `100`: that share of what the wallet holds. `"50"` is half.

A wrong amount does not get a `400`. The answer is `200` with `"ok": false` and the reason in `error`, like `amount must be a base-unit integer string`. Always check `ok`. A dry run checks the amount too, so try it first.

```json
{ "ok": true, "signature": "…", "burnedAmount": "3500000000", "walletAddress": "…", "mint": "…" }
```

A lock answers with `txId`, `metadataId`, `lockedAmount` and `unlockTimestamp`. The lock service takes its fee in the token, on top of the locked amount. If the wallet cannot cover both, the lock is made smaller, so `lockedAmount` can be less than you asked.

:::warning Burning cannot be undone
A burn with `dryRun: false` removes the tokens forever. Locked tokens stay locked until the unlock time.
:::

## Creator fees

[Creator fees](https://vortexdeployer.com/docs/other/glossary#creator-fees) are what a launchpad pays the token's creator from trading.

- `GET /tokens/creator-fees?mint=…&chain=…` (`read`) — what is waiting to be claimed. Some entries carry `unswept`.
- `POST /tokens/creator-fees/claim` — `{ "mint": "…", "chain": "solana" }`. It is real by default (`dryRun: false`).

Only your own launches with a creator wallet you keep in the app can claim. One transaction claims every place that holds at least 0.001 SOL for you. A place claimed in the last minute is skipped. On Robinhood Chain, and for pump.fun tokens with **Holder Rewards**, there is nothing to claim. The fees move by themselves.

If the creator wallet cannot pay what the claim costs, the claim is not sent. The answer has `"ok": false` and an `error` saying why.

## Refusals

| Status | Code | When |
|---|---|---|
| `400` | `validation_failed` | A field is missing, out of range or unknown. `details` names it. |
| `403` | `insufficient_scope` | The key lacks `trade`. |
| `403` | `over_trade_cap` | A buy is over the key's max per buy. |
| `403` | `over_daily_cap` | A buy would pass the key's daily cap. |
| `403` | `sandbox_key` | A sandbox key sent a real trade. |
| `403` | `wallet_not_allowed` | The wallet is not on the key's list. A `percentage` sell from a wallet that is not yours also gets this. |
| `403` | `forbidden` | The wallet is not yours. |
| `403` | `private_key_not_allowed` | A wallet-list key sent a private key. |
| `422` | `unprocessable` | Nothing to sell, or no route. |

## See also

- [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors)
- [Wallets, portfolio & PnL](https://vortexdeployer.com/docs/api/wallets-pnl)
- [Tasks API](https://vortexdeployer.com/docs/api/tasks)
- [Live streams](https://vortexdeployer.com/docs/api/streams)

---

# Launch a token

> Launch a token from code, with its image, creator wallet, first buys and launch tasks.

Source: https://vortexdeployer.com/docs/api/launch · Markdown: https://vortexdeployer.com/docs/api/launch.md

`POST /launch` creates a new token, just like the create form in the app. It needs a key with the `launch` [scope](https://vortexdeployer.com/docs/other/glossary#scope). The token becomes a [project](https://vortexdeployer.com/docs/other/glossary#project) in your account.

:::info A launch is a dry run unless you say otherwise
`POST /launch` only simulates unless you send `"dryRun": false`. A [dry run](https://vortexdeployer.com/docs/other/glossary#dry-run) checks the whole launch and sends nothing. Run one first.
:::

## Before you start

- A key with the `launch` scope. A [restricted key](https://vortexdeployer.com/docs/other/glossary#restricted-key) can only send dry-run launches.
- A creator wallet with enough coin to pay for the launch and any first buy.
- A picture for the token: PNG, JPEG, GIF or WebP, up to 10 MB.

## A first launch

```bash
curl -s -X POST https://evm.vortexdeployer.com/evm/api/v1/launch \
  -H "Authorization: Bearer vd_…" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: launch-vcat-0001" \
  -d '{
    "launchpad": "pump",
    "name": "Vortex Cat",
    "symbol": "VCAT",
    "description": "gm",
    "imageUrl": "https://example.com/cat.png",
    "creatorWalletId": "812",
    "devBuySol": 0.5
  }'
```

This is a dry run, because `dryRun` is left out. When the answer looks right, send the same body with `"dryRun": false` and a new `Idempotency-Key`.

## The body

### Required

- `name` — 1–32 characters.
- `symbol` — 1–10 characters.
- The image — send one of:
  - `imageUrl` — a public `https` link to the picture. The API downloads and checks it.
  - `imageBase64` — the picture as base64, or a `data:` URL. Add `imageContentType` (`image/png`, `image/jpeg`, `image/gif` or `image/webp`; default `image/png`).
- The creator — send one of:
  - `creatorWalletId` — a wallet in your account. It becomes the project's dev wallet.
  - `creatorPrivateKey` — a wallet's [private key](https://vortexdeployer.com/docs/other/glossary#private-key). The API adds the wallet to your account first.

### Where and how it trades

- `launchpad` — the [launchpad](https://vortexdeployer.com/docs/other/glossary#launchpad) that creates the token: `pump` (default), `raydium_launchlab`, `bonk`, `bonkers`, `stonkfun`, `meteora_dbc` or `pons`. `pons` is on Robinhood Chain; the rest are on Solana.
- `quoteToken` — the [quote token](https://vortexdeployer.com/docs/other/glossary#quote-token) the price is counted in: `sol` (default), `usdc`, `usd1`, `eth` or `stock`. Each launchpad takes only some of them. See [Which quotes a launchpad takes](#which-quotes-a-launchpad-takes).
- `pairToken` — the address of the [pair token](https://vortexdeployer.com/docs/other/glossary#pair-token), when the quote needs one. Every StonkFun launch and every pump.fun `stock` launch needs it. On `pons` it is optional.

### The creator's first buy

The [dev buy](https://vortexdeployer.com/docs/other/glossary#dev-buy) is the creator wallet's own buy, sent with the launch. Use one field:

- `devBuySol` — spent in SOL, 0–85. For SOL pairs and stock pairs.
- `devBuyQuote` — spent in the quote the creator holds, like USDC. 0–1,000,000.
- `devBuyEth` — on `pons` only, in ETH, 0–10.
- `devBuySlippageBps` — 0–10000, default 500.

`GET /launchpads` tells you which field each quote uses (`devBuyField`).

### Optional

- `description` — up to 1000 characters.
- `twitter`, `telegram`, `website` — links, up to 200 characters each.
- `buys` — up to 24 other wallets that buy in the same moment as the launch. Each is `{ "walletId": "813", "amountSol": 0.3 }` or `{ "privateKey": "…", "amountSol": 0.2 }`. `amountSol` is above 0 and at most 85. A wallet may appear once. Solana only. They ride the launch as one [bundle](https://vortexdeployer.com/docs/other/glossary#bundle).
- `tasks` — up to 20 tasks that start when the token exists. See [Launch tasks](#launch-tasks).
- `launches` — 1–10. Makes the same token that many times in a row. See [Several launches in one call](#several-launches-in-one-call).
- `launchAt` — launch later. See [Schedule a launch](#schedule-a-launch).
- `projectId` — a draft project to fill in, made earlier with `POST /projects`. Without it, a new project is made.
- `mintSecret` — the secret key of a token address you made yourself (a "vanity" address). Solana only, with `launches: 1`, and the address must be unused.
- `expectedMint` — the token address you expect. The launch stops if it would use another one.
- `launchId` — your own id, up to 64 characters. It comes back on every live `launch` event for this launch.
- `provider` — where the image and token info are stored: `local` (default), `pumpfun` or `pinata`.
- `computeUnitLimit` (default 250,000), `computeUnitPriceMicroLamports` (default 50,000) — Solana fee settings.
- `dryRun` — `true` (default) simulates, `false` sends.

Some fields belong to one launchpad. They are refused on any other:

- pump.fun: `isMayhemMode`, `isHolderReward`, `otcDesks` (SOL pairs only), `pumpCreatorFeeBps` (1–300, `stock` pairs only).
- StonkFun: `stonkfunMode` (`standard`, `reward` or `community`) and `stonkfunRewardTaxBps` (`100` or `300`). `community` works only on a stock that offers it. On any other stock the launch is refused with a 400: "StonkFun Community Mode is not offered on SYMBOL — pick Standard or Reward, or another pair". `GET /launchpads/stonkfun/quotes` does not say which stocks offer it.
- pons: `creatorFeeMode` (`creator`, `holders` or `custom`), `creatorFeeAddress` (with `custom`), `creatorTaxBps`, `buybackEnabled`.

The full list, with every limit, is in `https://evm.vortexdeployer.com/evm/api/v1/openapi.json`.

## Launch tasks

`tasks` is the list of [tasks](https://vortexdeployer.com/docs/other/glossary#task) the launch creates for the new token. They work like tasks made after the launch, but you write them on the launch itself. You do not create them first.

Each task has:

- `type` — the engine: `bundle`, `sniper`, `buy`, `volume`, `antisniper`, `holderboost`, `handswitcher`, `fakevolume`, `protrader_boost`, `limit_order`, `ladder`, `mirror`, `dca`, `trailing_stop` or `tokendisperser`.
- `walletIds` — the wallets it uses. They must be yours, and on the key's list if it has one. It may be empty only for a `limit_order` whose `config.walletSource` is `all` or `roles`.
- `config` — the engine's settings. These are the same keys as in a `POST /tasks` body. Leave out `mint` and `chain`; the launch fills them in.
- `label` — optional, up to 120 characters.
- `autostart` — `true` (default) starts the task the moment the token exists. `false` leaves it waiting on the project.

```json
"tasks": [
  { "type": "sniper", "walletIds": ["814", "815"], "config": { "buyMode": "range", "minBuySol": 0.03, "maxBuySol": 0.05 } },
  { "type": "dca", "walletIds": ["816"], "autostart": false, "label": "later",
    "config": { "side": "buy", "everyMs": 60000, "sizeUnit": "native", "sizeValue": 0.01, "maxFires": 10 } }
]
```

Check each engine's fields on the [Tasks API](https://vortexdeployer.com/docs/api/tasks) page and in the OpenAPI document. A field the engine does not know is ignored, and the default is used instead. For `sniper` and `buy`, the default `buyMode` is `full_balance`: every picked wallet spends almost all of its coin.

Rules:

- Every task is checked before anything is sent. A bad setting refuses the whole launch with `400 validation_failed`, and `details` points at `tasks[i].config`.
- The launch's `dryRun` decides for every task. A `dryRun` inside `config` is ignored.
- Most engines have no dry run. Only `sniper`, `buy` and `tokendisperser` can ride a dry-run launch. Any other type, and `buys`, refuse a dry run with `400`. To try the launch, leave those out.
- A trading task leaves the creator wallet out, unless it is the only wallet you picked or `config.includeDev` is `true`.
- A key limited to a wallet list must name `walletIds`. It cannot use `walletSource`.

`POST /launch/affordability` takes the same `tasks` list, so you can price the plan first.

## What a launch returns

```json
{
  "projectId": "1021",
  "mint": "J11L…pump",
  "creator": "6729…CE88",
  "launchpad": "pump",
  "quoteToken": "sol",
  "pool": null,
  "dryRun": false,
  "signature": "3BNE…L98",
  "confirmed": true,
  "err": null,
  "devBuyTokens": "17504000000000",
  "uri": "…/metadata/….json",
  "imageUri": "…/image/….png",
  "tasks": [ { "type": "sniper", "taskId": "4400", "started": true } ]
}
```

- `mint` — the new token's [mint address](https://vortexdeployer.com/docs/other/glossary#mint-address).
- `signature`, `confirmed`, `err` — the create transaction, as for a trade.
- `devBuyTokens` — tokens the dev buy got, in base units, or `null`.
- `uri`, `imageUri` — where the token info and picture are stored.
- `tasks` — one entry per launch task: its `taskId` and `started`, or an `error`.
- `simulation` — on a dry run only: `{ "err", "unitsConsumed", "logsTail" }`. A dry run has `signature: null` and `confirmed: false`.

Some launches add more: `bundle` (the buys in the bundle), `preSwap` (a swap into the quote before the launch), `creatorFees`, `otcDesks`, and on `pons` `launchBuys` and the quote's `quoteMint`, `quoteSymbol` and `quoteDecimals`.

## Several launches in one call

With `launches` above 1, the API makes the same token again and again, one after another. Each launch has the same name, creator, dev buy and tasks. The answer is the first launch plus a `batch` report:

- `requested` and `landed` — how many you asked for and how many were made.
- `launches` — one entry per launch.
- `stoppedAt`, `stopReason` — where and why the run stopped, if it did.
- `affordable`, `affordabilityStop` — how many launches the wallets could pay for.

Before a real run, the API counts how many launches the wallets can pay for. It makes only that many, and never fewer than one. The run also stops at the first later launch that fails. Launches already made stay up with their tasks running. A dry run tries one launch, whatever `launches` says.

## Schedule a launch

`launchAt` is a date and time with a time zone, like `"2026-10-20T15:00:00Z"`. It must be at least 30 seconds ahead and at most 30 days ahead.

The API stores the token info at once and answers `202`:

```json
{ "scheduled": true, "taskId": "4401", "projectId": "1022", "launchAt": "2026-10-20T15:00:00Z", "uri": "…", "imageUri": "…" }
```

Nothing is made until then. The launch waits as a task of type `scheduled_launch` on the project. Stop that task to cancel. `launchId` cannot be used with `launchAt`.

## Which quotes a launchpad takes

Two `read` calls answer this:

- `GET /launchpads` — every launchpad, its chain, and the `quoteToken` values it takes. For each quote it says whether a `pairToken` is `none`, `optional` or `required`, and its `devBuyField`.
- `GET /launchpads/:launchpad/quotes` — what a launch there can use right now. Each entry has the exact `quoteToken` and `pairToken` to send.

Today the rules are:

| Launchpad | Quotes |
|---|---|
| `pump` | `sol`, `usdc`, `stock` |
| `raydium_launchlab`, `bonk`, `bonkers` | `sol`, `usd1` |
| `meteora_dbc` | `sol` |
| `stonkfun` | `stock` |
| `pons` | `eth`, or an approved pair token |

Stock lists change when the launchpad changes them. If a launchpad's list cannot be read, the answer is `503`. Try again. An unknown launchpad is `404`.

## Checks before you launch

These calls check a launch and make nothing. All need `read`, except `POST /launch/metadata`, which needs `launch`.

| Call | What it does |
|---|---|
| `GET /launch/readiness` | Says if real launches are on. `killSwitch: true` means real sends are off for everyone right now. |
| `GET /launch/mint-address?launchpad=pump` | The token address the next launch there will get. |
| `POST /launch/clone` | `{ "chain", "address" }` of an existing token. Returns its name, symbol, description, links and picture, ready for a launch body. |
| `POST /launch/affordability` | How many of `launches` the creator and buyers can pay for, from live balances. |
| `POST /launch/supply-preview` | What share of the supply each first buy would get. |
| `POST /launch/metadata` | Stores the picture and token info now. Returns `uri` and `imageUri`. |
| `GET /launch/pons/launch-terms` | The current pons terms. |
| `GET /launch/otcdesks/rewards` | The rewards an OTC Desks pairing can pay. |

## Supply plans

A [supply plan](https://vortexdeployer.com/docs/other/glossary#supply-plan) is a saved layout of first buys, as a share of the token's supply per wallet slot.

- `GET /supply-plans` (`read`) — your plans.
- `POST /supply-plans` (`trade`) — save one.
- `DELETE /supply-plans/:id` (`trade`) — remove one.
- `POST /supply-plans/:id/mount` (`read`) — fit a plan to wallets. Send `walletIds` and either `launchpad` and `quoteToken` for a new token, or `mint` for a token that already trades.

```json
{
  "name": "12 wallets, 18%",
  "slots": [ { "targetPercent": 1.5, "walletId": "812" }, { "targetPercent": 1.5, "role": "trading" } ],
  "maxTotalPercent": 18,
  "maxWalletPercent": 2
}
```

A slot can name a `walletId`, or a `role` the wallet must have. A slot with neither takes the next wallet you send when you mount the plan. The slots may not add up to more than 100%.

## Refusals

| Status | Code | When |
|---|---|---|
| `400` | `validation_failed` | A field is missing or out of range, or a launch task's `config` is wrong. `details` names it. |
| `400` | `bad_request` | Two images or no image, two creators or none, `buys` on a non-Solana launchpad, or a picture that is not a real image. |
| `403` | `key_restricted` | A restricted key sent `dryRun: false`. |
| `403` | `wallet_not_allowed` | A wallet is not on the key's list, or a task's wallet is not yours. |
| `403` | `forbidden` | The creator wallet is not yours. |
| `403` | `private_key_not_allowed` | A wallet-list key sent a private key. |
| `409` | `conflict` | `projectId` already has a token. |

## See also

- [API overview & keys](https://vortexdeployer.com/docs/api/overview)
- [Tasks API](https://vortexdeployer.com/docs/api/tasks)
- [Wallets, portfolio & PnL](https://vortexdeployer.com/docs/api/wallets-pnl)
- [Create a project](https://vortexdeployer.com/docs/launch/create-project)

---

# Tasks API

> Create, start, edit and follow tasks from code, and read your activity feed.

Source: https://vortexdeployer.com/docs/api/tasks · Markdown: https://vortexdeployer.com/docs/api/tasks.md

A [task](https://vortexdeployer.com/docs/other/glossary#task) is a job that trades for you over time, like a volume run or a ladder of sells. The API makes the same tasks as the app, and they show up in the app too.

## Before you start

- Reading tasks needs the `read` [scope](https://vortexdeployer.com/docs/other/glossary#scope). Creating and controlling them needs `trade`.
- Creating, editing, starting and resuming need a key with no limits. A [restricted key](https://vortexdeployer.com/docs/other/glossary#restricted-key) gets `403 key_restricted`. Pausing, stopping and deleting work with any `trade` key.
- Tasks are real by default. They send real transactions unless their `config` says `"dryRun": true`, and many types cannot do a [dry run](https://vortexdeployer.com/docs/other/glossary#dry-run) at all. See [Dry runs](#dry-runs).

## Routes

| Call | Scope | What it does |
|---|---|---|
| `GET /tasks` | `read` | Your tasks. |
| `GET /tasks/:id` | `read` | One task. |
| `POST /tasks` | `trade` | Create a task. |
| `PATCH /tasks/:id` | `trade` | Change its label, settings or wallets, even while it runs. |
| `POST /tasks/:id/start` | `trade` | Start it. |
| `POST /tasks/:id/pause` | `trade` | Pause it. |
| `POST /tasks/:id/resume` | `trade` | Go on after a pause. |
| `POST /tasks/:id/stop` | `trade` | Stop it. |
| `DELETE /tasks/:id` | `trade` | Delete a task that is not running. |
| `POST /tasks/stop-all` | `trade` | Stop all your running and paused tasks. |
| `POST /tasks/:id/preview` | `read` | What a start would do now. Sends nothing. |
| `GET /tasks/:id/executions` | `read` | The trades it sent. |
| `GET /tasks/:id/postmortem` | `read` | How each wallet did, and why any failed. |
| `GET /tasks/:id/playbook` | `read` | Live state of a limit order, ladder, mirror, DCA or trailing stop. |
| `GET /tasks/:id/mixer-orders` | `read` | A mixer task's orders. |
| `POST /tasks/:id/mixer-orders/:orderId/recipients/:recipientId/execute` | `trade` | Skip the wait for one mixer recipient. |
| `GET /tasks/:id/disperse` | `read` | A SOL-spreading task's wallets and progress. |
| `GET /tasks/presets`, `POST /tasks/presets`, `DELETE /tasks/presets/:id` | `read` / `trade` | Saved settings. |
| `GET /events` | `read` | Your activity feed. |
| `GET /warmup/candidates` | `read` | Tokens the wallet warm-up task would trade now. |

## Create a task

`POST /tasks`:

```json
{
  "type": "buy",
  "mint": "7xKX…pump",
  "walletIds": ["812", "813"],
  "label": "morning buys",
  "config": {
    "buyMode": "exact",
    "walletAmounts": { "812": 0.1, "813": 0.05 },
    "minDelayMs": 2000,
    "maxDelayMs": 9000
  },
  "autostart": false
}
```

- `type` — the engine. See [Task types](#task-types).
- `mint` — the token's [mint address](https://vortexdeployer.com/docs/other/glossary#mint-address).
- `walletIds` — the wallets it uses. They must be yours. It may be empty only for a `limit_order` whose `config.walletSource` is `all` or `roles`.
- `config` — the engine's settings. Each engine has its own fields.
- `chain` — optional. Left out, it comes from the mint's address.
- `label` — optional, up to 120 characters.
- `projectId` — optional. Puts the task under one of your projects.
- `autostart` — `true` starts it at once. Default `false`.

The answer is `201` with the task. A wallet that is not yours gets `403 forbidden`. Bad settings get `400 validation_failed`, and `details` names the field.

:::warning Check the spelling of every setting
A `config` field the engine does not know is ignored, and its default is used instead. Some defaults spend a lot. For `buy`, the default `buyMode` is `full_balance`: each wallet spends almost all its coin. Read the task back with `GET /tasks/:id` and check `config` before you start it.
:::

## Task types

Each type's settings match its form in the app. Its docs page explains them.

| `type` | Page |
|---|---|
| `buy` | [Buy](https://vortexdeployer.com/docs/tasks/buy) |
| `volume` | [Volume](https://vortexdeployer.com/docs/tasks/volume) |
| `fakevolume` | [Fake volume](https://vortexdeployer.com/docs/tasks/fake-volume) |
| `holderboost` | [Holder boost](https://vortexdeployer.com/docs/tasks/holder-boost) |
| `protrader_boost` | [Pro trader boost](https://vortexdeployer.com/docs/tasks/pro-trader-boost) |
| `handswitcher` | [Hand switcher](https://vortexdeployer.com/docs/tasks/hand-switcher) |
| `antisniper` | [Anti-sniper](https://vortexdeployer.com/docs/tasks/anti-sniper) |
| `bundle` | [Bundle](https://vortexdeployer.com/docs/tasks/bundle) |
| `migrate_and_buy` | [Migrate and buy](https://vortexdeployer.com/docs/tasks/migrate-and-buy) |
| `tokendisperser` | [Token sender](https://vortexdeployer.com/docs/tasks/token-sender) |
| `mixer` | [Mixer](https://vortexdeployer.com/docs/tasks/mixer) |
| `warmup` | [Wallet warm-up](https://vortexdeployer.com/docs/tasks/wallet-warmup) |
| `limit_order` | [Limit order](https://vortexdeployer.com/docs/tasks/limit-order) |
| `ladder` | [Ladder](https://vortexdeployer.com/docs/tasks/ladder) |
| `mirror` | [Mirror](https://vortexdeployer.com/docs/tasks/mirror) |
| `dca` | [DCA](https://vortexdeployer.com/docs/tasks/dca) |
| `trailing_stop` | [Trailing stop](https://vortexdeployer.com/docs/tasks/trailing-stop) |

Some types follow special rules:

- `sniper` is a launch task only. Add it to `tasks` on `POST /launch`. On a token that already trades, use `buy`.
- `batch` is made for you by a slow `POST /trade/batch`. See [Buy, sell & batches](https://vortexdeployer.com/docs/api/trading).
- `scheduled_launch` is made for you by `POST /launch` with `launchAt`. See [Launch a token](https://vortexdeployer.com/docs/api/launch).
- `devwarmup` needs exactly one wallet. Starting it needs the highest fee tier, or it gets `403`.
- `soldisperser`, `solcollector`, `tokencollector` and `sendsol` move coins between your wallets.

## Dry runs

Types such as `buy`, `migrate_and_buy`, `warmup`, `tokendisperser` and `mixer` take `"dryRun": true` inside `config`. The task walks through its steps and sends nothing. Its trades show up as `simulated`.

These types have no dry run: `volume`, `bundle`, `antisniper`, `holderboost`, `handswitcher`, `fakevolume`, `protrader_boost`, `limit_order`, `ladder`, `mirror`, `dca` and `trailing_stop`. They refuse `"dryRun": true` with `400 validation_failed`. Start them with small amounts first.

`POST /tasks/:id/preview` shows what a start would do right now, from live balances. Nothing moves. A type with no preview, like the ones above, gets `400`.

## Control a task

A task's `status` is one of:

- `idle` — made, not started.
- `running` — working now.
- `paused` — waiting for `resume`.
- `completed` — done.
- `failed` — stopped by an error. `lastError` says why.
- `stopped` — stopped by you.
- `timeout` — ran out of time.

`start`, `pause`, `resume` and `stop` answer with the task. A call that does not fit the status, like `pause` on a stopped task, gets `409 conflict`. A finished task can be started again.

`PATCH /tasks/:id` takes `label` (`null` clears it), `config` and `walletIds`. Send at least one. A running task picks up the change in place.

`DELETE /tasks/:id` works only when the status is `idle`, `completed`, `failed`, `stopped` or `timeout`. Otherwise it gets `409`, so stop the task first. The answer is `{ "ok": true, "id": "6186" }`. The task leaves your lists, but its trades stay in your history.

`POST /tasks/stop-all` stops all your running and paused tasks. One failure does not block the rest:

```json
{ "requested": 3, "stopped": ["6186", "6190"], "failed": [ { "id": "6201", "error": "…" } ] }
```

## Read a task

`GET /tasks` answers `{ "tasks": [ … ] }`.

- Filter with `?status=` or `?type=`.
- Page with `?limit=` (1–500, default 200) and `?offset=`. The full count is in `X-Total-Count`.
- `?status=active` lists your running and paused tasks, with no paging.
- `?mint=` lists the tasks on one token, with no paging.

A task looks like this:

```json
{
  "id": "6186",
  "type": "buy",
  "status": "running",
  "running": true,
  "chain": "solana",
  "mint": "7xKX…pump",
  "label": "morning buys",
  "projectId": null,
  "walletIds": ["812", "813"],
  "config": { "buyMode": "exact", "…": "…" },
  "lastError": null,
  "createdAt": "2026-09-16T01:09:24.500Z",
  "updatedAt": "2026-09-16T01:09:24.531Z",
  "startedAt": "2026-09-16T01:09:24.531Z",
  "stoppedAt": null
}
```

`GET /tasks/:id/executions` answers `{ "executions": [ … ] }`, newest first. Each row has:

- `walletId`, `side` (`buy` or `sell`), `signature`, `confirmed`, `err` and `createdAt`;
- `amountIn` and `amountOut`, in [base units](https://vortexdeployer.com/docs/other/glossary#base-units);
- `outcome` — `filled`, `pending`, `failed` or `simulated`.

Take up to 500 rows with `?limit=` (default 50). For older rows, send the last row's `id` as `?before=`.

A task that is not yours answers `404`, as if it did not exist.

## Presets

A preset saves a task's settings under a name.

- `GET /tasks/presets` — answers `{ "presets": [ … ] }`.
- `POST /tasks/presets` — send `{ "name": "fast buys", "type": "buy", "config": { … } }`. The name is 1–64 characters. Saving under a name you already used replaces that preset. Answers `201` with `{ "preset": … }`.
- `DELETE /tasks/presets/:id` — answers `{ "deleted": "…" }`, or `404`.

A preset's settings are not checked when you save it. They are checked when you send them in `POST /tasks`.

## Events

`GET /events` is your activity feed: every task change and every trade, one row each, newest first.

```json
{
  "events": [
    { "id": "918273", "ts": "2026-09-16T20:11:02.000Z", "category": "execution", "type": "task_execution",
      "severity": "success", "taskId": "6605", "mint": "7xKX…pump", "walletId": "812", "title": "Buy landed", "data": { } }
  ],
  "nextBefore": "918200"
}
```

- Filter with `category` (`task` or `execution`), `taskId`, `mint` or `severity` (`info`, `success`, `warn`, `error`).
- `limit` is 1–200, default 50.
- For the next older page, send `nextBefore` back as `?before=`. It is `null` on the last page.

`GET /warmup/candidates?chain=solana&limit=20` lists the tokens the warm-up task would trade right now.

## Follow a task live

Subscribe to the `tasks` topic on the [live stream](https://vortexdeployer.com/docs/api/streams) with a `read` key. You get your tasks now, then every change as it happens. This beats asking `GET /tasks` again and again.

## See also

- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Launch a token](https://vortexdeployer.com/docs/api/launch)
- [Live streams](https://vortexdeployer.com/docs/api/streams)
- [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors)

---

# Wallets, portfolio & PnL

> Create, list and organise wallets, read balances and holdings, manage projects and read profit and loss from code.

Source: https://vortexdeployer.com/docs/api/wallets-pnl · Markdown: https://vortexdeployer.com/docs/api/wallets-pnl.md

These calls manage the wallets in your account and read what they hold and how they did. Reads need the `read` [scope](https://vortexdeployer.com/docs/other/glossary#scope). Every change needs `trade`.

## Wallet calls

| Call | Scope | What it does |
|---|---|---|
| `GET /wallets` | `read` | Your wallets. |
| `GET /wallets/balances` | `read` | Each wallet's coin balance. |
| `GET /wallets/token-balances?mint=…` | `read` | One token's balance in each wallet. |
| `POST /wallets` | `trade` | Make new wallets or import your own. |
| `PATCH /wallets/:id` | `trade` | Rename a wallet, change its role or move it to a group. |
| `DELETE /wallets/:id` | `trade` | Delete one wallet. |
| `POST /wallets/delete` | `trade` | Delete many wallets. |
| `POST /wallets/move` | `trade` | Move many wallets to a group. |
| `GET /wallets/:id/profile` | `read` | One wallet's trading history in numbers. |
| `GET /wallets/groups`, `POST /wallets/groups` | `read` / `trade` | List or make groups. |
| `PATCH /wallets/groups/:id`, `DELETE /wallets/groups/:id` | `trade` | Rename or delete a group. |
| `GET /wallets/cashback`, `POST /wallets/cashback/claim` | `read` / `trade` | Read and claim pump.fun cashback. |

:::info The API never shows private keys
No call returns a wallet's [private key](https://vortexdeployer.com/docs/other/glossary#private-key). To export keys, use the app with your password. See [Export a private key](https://vortexdeployer.com/docs/wallets/key-export).
:::

## List wallets

`GET /wallets` answers `{ "wallets": [ … ] }`:

```json
{
  "wallets": [
    {
      "id": "812",
      "chain": "solana",
      "address": "7tXi4mbvppPBgYgTVj2NpYq9K1KYYQvHv6tfCpJv9kMT",
      "role": "dev",
      "label": "main dev",
      "groupId": null,
      "projectId": null,
      "createdAt": "2026-08-29T10:03:44.318Z"
    }
  ]
}
```

- By default it lists the wallets in your shared pool. `?scope=all` adds wallets made inside a project.
- `?groupId=` lists one group. `?chain=` lists one chain.
- Page with `?limit=` (1–500, default 200) and `?offset=`. The full count is in the `X-Total-Count` header.

A key limited to a wallet list still sees every wallet. It can only use, change or delete the ones on its list.

## Read balances

`GET /wallets/balances` gives each wallet's coin balance in base units. On Solana that is lamports: 1 SOL is 1,000,000,000 lamports.

```json
{
  "balances": [
    { "id": "812", "address": "7tXi…9kMT", "chain": "solana", "role": "dev", "label": "main dev",
      "lamports": "419434195", "block": 447482145, "seeded": true }
  ],
  "totalLamports": "31497186480",
  "walletCount": 716
}
```

`seeded: false` means the balance has not been read yet. It shows `"0"` until then. Add `?chain=` for one chain. The list pages like `GET /wallets`.

`GET /wallets/token-balances?mint=…` gives one token's balance in each wallet, as a map from wallet id to [base units](https://vortexdeployer.com/docs/other/glossary#base-units). `mint` is required.

```json
{ "mint": "7xKX…pump", "balances": { "812": "3512000000", "813": "0" } }
```

## Make or import wallets

`POST /wallets` makes new wallets:

```json
{ "chain": "solana", "count": 5, "label": "bot fleet" }
```

- `chain` — default `solana`.
- `count` — how many, 1–1000. Default 1.
- `label` — up to 120 characters. With more than one wallet, each label gets a number: `bot fleet 1`, `bot fleet 2`. Put `{n}` in the label to place the number yourself.
- `labelStart` — the first number. Use it to go past 1000 over several calls. The second call of 2,500 wallets sends `"count": 1000, "labelStart": 1001`.
- `projectId` — put the wallets in one of your projects. An id that is not yours gets `404`.

To import wallets you already have, send `privateKey` (one) or `privateKeys` (up to 1000) instead of `count`:

```json
{ "chain": "solana", "privateKeys": ["5Kd3…", "3xQe…"], "label": "imported" }
```

- An import is all or nothing. One bad or repeated key gets `400` naming its place, like `privateKeys[2]`, and nothing is saved.
- A wallet you already have comes back as it is. Its role, label and group do not change. So you can safely send the same list again after a timeout.
- A key that cannot be used on your account gets `409`.
- A key limited to a wallet list cannot import (`403 private_key_not_allowed`).

The answer is `201` with `{ "wallets": [ … ] }`. New wallets have the role `trading`.

## Change a wallet

`PATCH /wallets/:id` takes any of:

- `label` — up to 120 characters. `null` clears it.
- `role` — the wallet's [role](https://vortexdeployer.com/docs/other/glossary#wallet-role), like `dev` or `trading`. Lowercase letters, digits and `_`, up to 32 characters.
- `groupId` — move the wallet into a group. `null` takes it out.

The answer is `{ "wallet": { … } }`. An empty body or an unknown field gets `400`.

## Delete wallets

`DELETE /wallets/:id` removes a wallet from your lists. It moves no funds. If you import the same private key later, the wallet comes back. The answer is `{ "deleted": "812" }`.

It gets `409 conflict` when:

- a running or paused task uses the wallet. Stop the task first.
- a project uses the wallet. The error lists them in `projects`. To delete it anyway, send `DELETE /wallets/:id?force=true`. That also takes it out of those projects.

A wallet that is not yours gets `404`.

`POST /wallets/delete` deletes many in one call:

```json
{ "walletIds": ["812", "813", "814"], "force": false }
```

Each refusal comes back per wallet, and the rest are deleted:

```json
{
  "deleted": ["812"],
  "active": [ { "id": "813", "taskId": "4410" } ],
  "assigned": [ { "id": "814", "projects": [ { "id": "1021", "name": "Moon", "symbol": "MOON" } ] } ],
  "missing": []
}
```

- `active` — a task uses it. Stop the task first.
- `assigned` — a project uses it. Send these again with `"force": true` to delete them anyway.
- `missing` — not yours, or already deleted.

## Groups

A group is a [folder](https://vortexdeployer.com/docs/other/glossary#folder) on the Wallets page. It only sorts wallets. It moves no funds. A wallet is in at most one group.

- `POST /wallets/groups` with `{ "name": "snipers" }` (1–64 characters) answers `201 { "group": { "id": "728", "name": "snipers", "walletCount": "0", "createdAt": "…" } }`. A name you already use gets `409`.
- `GET /wallets/groups` answers `{ "groups": [ … ] }`.
- `PATCH /wallets/groups/:id` renames it. Same body.
- `DELETE /wallets/groups/:id` answers `{ "deleted": "728" }`. Its wallets stay, without a group.
- `POST /wallets/move` with `{ "walletIds": ["812", "813"], "groupId": "728" }` moves many wallets. `"groupId": null` takes them out. It answers `{ "moved": [ … ], "missing": [ … ] }`. A group that is not yours gets `403`.

## Wallet profile

`GET /wallets/:id/profile` sums up one wallet's real trades:

```json
{
  "profile": {
    "walletId": "812", "chain": "solana", "address": "7tXi…9kMT", "role": "dev", "label": "main dev",
    "createdAt": "2026-08-29T10:03:44.318Z", "ageDays": 18, "lastActivityAt": "2026-09-15T20:11:02.000Z",
    "tradeCount": 141, "buyCount": 80, "sellCount": 61, "distinctMints": 9, "holderPositions": 3,
    "solSpentLamports": "1048881293", "solReceivedLamports": "552401905"
  }
}
```

## Cashback

[Cashback](https://vortexdeployer.com/docs/other/glossary#cashback) is what pump.fun pays a wallet back for trading certain coins. It waits in a vault until the wallet claims it.

`GET /wallets/cashback` lists, per Solana wallet, the `earned`, `claimed` and `claimable` amounts in lamports. `needsWsolAccount: true` means the first claim also opens the wallet's [wrapped SOL](https://vortexdeployer.com/docs/other/glossary#wrapped-sol) account. That costs about 0.002 SOL of rent, which stays in the wallet.

`POST /wallets/cashback/claim` claims:

```json
{ "walletIds": ["812", "813"], "dryRun": true }
```

- `dryRun` defaults to `true`. Send `false` to claim for real.
- The claimed SOL stays wrapped in the wallet's wrapped SOL account.
- The answer is `{ "dryRun": true, "outcomes": [ { "walletId", "address", "label", "claimable", "ok", "signature", "err" } ] }`.
- A sandbox key can only dry-run. A wallet-list key can only claim for its own wallets.

## Portfolio

| Call | What it gives |
|---|---|
| `GET /portfolio` | Coin totals and per-wallet balances. |
| `GET /portfolio/holdings` | The tokens your wallets hold, summed per token. |
| `GET /portfolio/pnl` | PnL per token. The same as `GET /pnl`. |
| `GET /portfolio/daily` | Trading results per UTC day. |

All take `?chain=` (default `solana`).

`GET /portfolio` answers `chain`, `sol` (`totalLamports`, `walletCount` and the paged `balances`), `trading`, and `totalValueLamports`: coins plus tokens, valued in lamports. `unpricedAssets` counts what could not be valued.

`GET /portfolio/holdings`:

```json
{
  "chain": "solana",
  "holdings": [
    { "mint": "7xKX…pump", "symbol": "VCAT", "name": "Vortex Cat", "decimals": 6,
      "rawAmount": "51920524244101", "uiAmount": 51920524.244101, "walletCount": 23,
      "wallets": [ { "id": "812", "address": "…", "label": "bot 1" } ] }
  ],
  "totalValueLamports": "2276357388",
  "valuation": "live"
}
```

`GET /portfolio/daily?days=30` gives one row per UTC day with trades: `buyCount`, `sellCount`, `solSpentLamports`, `solReceivedLamports`, `netLamports` and `feesLamports`. Days default to 90, up to 366.

## PnL

[PnL](https://vortexdeployer.com/docs/other/glossary#pnl) is profit and loss: what you got back minus what you spent.

`GET /pnl` lists every token you traded on one chain, biggest movers first, up to 100:

```json
{
  "chain": "solana",
  "tokens": [
    { "mint": "7xKX…pump", "symbol": "VCAT", "buyCount": 23, "sellCount": 0,
      "solSpentLamports": "2294703578", "solReceivedLamports": "0",
      "realizedSolPnlLamports": "-2294703578", "feesLamports": "225000",
      "held": true, "currentValueLamports": "2276357388", "totalPnlLamports": "-18346190" }
  ]
}
```

- `realizedSolPnlLamports` — received minus spent, from trades that landed.
- `currentValueLamports` — what the tokens you still hold would sell for now. `null` when no pool can price them.
- `totalPnlLamports` — realized plus current value. `null` when either part is unknown.

`GET /pnl?mint=…` gives one token's PnL in USD, the figure on its share card:

```json
{ "mint": "7xKX…pump", "pnl": { "profitUsd": 42.17, "profitQuote": 0.271, "quoteUsd": 155.6, "wallets": 3, "trades": 12, "held": 3512000000, "spotQuote": 0.0000004 } }
```

When the token cannot be priced, `pnl` is `null` and `reason` says why.

`POST /pnl/wallet-totals` adds up one token's trades for a set of your Solana wallet addresses:

```json
{ "mint": "7xKX…pump", "wallets": ["7tXi…9kMT"], "quoteMint": "So11111111111111111111111111111111111111112" }
```

It answers `boughtRaw`, `soldRaw`, `cashChangeRaw`, `buys` and `sells` per wallet and in `total`. An address that is not yours gets `403`.

For live PnL, subscribe to `pnl` on the [live stream](https://vortexdeployer.com/docs/api/streams).

## Projects

A [project](https://vortexdeployer.com/docs/other/glossary#project) holds one token: its details, its wallets and its tasks.

| Call | Scope | What it does |
|---|---|---|
| `GET /projects` | `read` | Your projects, newest first. |
| `GET /projects/:mint`, `GET /projects/by-id/:id` | `read` | One project. |
| `POST /projects` | `trade` | Make a [draft](https://vortexdeployer.com/docs/other/glossary#draft): a project with no token yet. |
| `POST /projects/cto` | `trade` | Take over a token that already trades. |
| `PATCH /projects/:id` | `trade` | Change its name, symbol, launchpad or dev wallet. |
| `DELETE /projects/:id` | `trade` | Delete it. |
| `GET /projects/:id/wallets` | `read` | Its wallets. |
| `POST /projects/:id/wallets/assign` | `trade` | Add wallets from your pool. |
| `DELETE /projects/:id/wallets/:walletId`, `POST /projects/:id/wallets/remove` | `trade` | Take wallets out. |
| `POST /projects/:id/closeout` | `trade` | Sell the token from every project wallet and collect the coin. |

`GET /projects` answers `{ "projects": [ … ], "launchedTotal": 12, "nextCursor": null }`. Each project has `id`, `chain`, `mint`, `name`, `symbol`, `launchpad`, `devWalletId`, `dryRun`, `launchedAt`, `createdAt`, `metadataUri` and `market`. Take up to 200 with `?limit=` (default 100). For the next page, send `nextCursor` back as `?cursor=`.

`POST /projects` makes a draft. Every field is optional:

```json
{ "chain": "solana", "name": "Vortex Cat", "symbol": "VCAT", "launchpad": "pump", "devWalletId": "812" }
```

Launch it later with `POST /launch` and its `projectId`. See [Launch a token](https://vortexdeployer.com/docs/api/launch).

`POST /projects/cto` with `{ "chain": "solana", "mint": "…" }` makes a project from a token that already trades, so tasks can work on it. See [CTO an existing token](https://vortexdeployer.com/docs/launch/cto). An unknown token gets `404`.

`PATCH /projects/:id` takes `name` (up to 64), `symbol` (up to 16), `launchpad` or `devWalletId`. After launch, name, symbol and launchpad are fixed, and changing them gets `409`. `DELETE /projects/:id` answers `{ "deleted": "1021" }`. The project's wallets are not deleted: they move to your pool.

### A project's wallets

- `GET /projects/:id/wallets` lists them. `origin` is `project` for a wallet made inside the project, or `assigned` for a wallet from your pool.
- `POST /projects/:id/wallets/assign` with `{ "walletIds": ["813", "814"] }` adds wallets. It answers `{ "assigned": [ … ], "skipped": [ … ] }`.
- `DELETE /projects/:id/wallets/:walletId` answers `{ "walletId": "813", "outcome": "unassigned" }`. The wallet leaves the project and stays in your pool. A wallet made inside the project moves to your pool. No wallet is deleted.
- `POST /projects/:id/wallets/remove` with `{ "walletIds": [ … ] }` answers `{ "deleted": [], "unassigned": [ … ], "missing": [ … ] }`. `deleted` is always empty.

### Close out a project

`POST /projects/:id/closeout` sells the token from every project wallet. On Solana it also closes the emptied token accounts. Then it starts a task that sweeps the coin to one wallet.

```json
{ "destinationWalletId": "812", "dryRun": true }
```

`dryRun` defaults to `true`: nothing is sent, and the sweep task is made as a dry run. Send `false` to close out for real.

```json
{
  "projectId": "1021", "mint": "J11L…pump", "chain": "solana", "symbol": "VCAT", "dryRun": true,
  "sells": [ { "walletId": "813", "address": "…", "amountRaw": "3512000000", "ok": true, "signature": null, "err": null } ],
  "closed": [], "sweep": { "taskId": "6868", "sources": 1 }, "skipped": []
}
```

`skipped` says, in words, what could not run. A [restricted key](https://vortexdeployer.com/docs/other/glossary#restricted-key) can only dry-run (`403 key_restricted`).

## See also

- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)
- [Portfolio](https://vortexdeployer.com/docs/account/portfolio)
- [Live streams](https://vortexdeployer.com/docs/api/streams)
- [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors)

---

# Wallet marketplace

> Browse the Wallet Marketplace, order wallets, pay for them and follow the order from code.

Source: https://vortexdeployer.com/docs/api/marketplace · Markdown: https://vortexdeployer.com/docs/api/marketplace.md

These calls do what the [Wallet Marketplace](https://vortexdeployer.com/docs/wallets/marketplace) page does in the app: list the wallets for sale, reserve the ones you pick, and hand them to you once you pay. Reads need the `read` [scope](https://vortexdeployer.com/docs/other/glossary#scope). Making an order and checking it need `trade`.

| Call | Scope | What it does |
|---|---|---|
| `GET /marketplace/inventory` | `read` | The wallets for sale. |
| `GET /marketplace/inventory/stats` | `read` | A summary of one wallet type. |
| `POST /marketplace/orders` | `trade` | Reserve wallets and get a payment address. |
| `GET /marketplace/orders/:id` | `read` | One order, with your wallets once paid. |
| `POST /marketplace/orders/:id/check` | `trade` | Look for your payment now. |
| `GET /marketplace/orders` | `read` | Your last 50 orders. |

:::info An order moves no funds
Making an order only reserves wallets. You then pay from any wallet you like, in the app, an exchange or your own code. Because the API sends nothing, a key's max per buy, daily cap and wallet list do not apply to these calls.
:::

## How a purchase goes

1. List the wallets for sale with `GET /marketplace/inventory`.
2. Pick the ones you want. Note each one's `id` and add up their `priceRaw`. That sum is your `expectedTotal`.
3. Make a [request key](https://vortexdeployer.com/docs/other/glossary#request-key): a fresh UUID of your own.
4. Send `POST /marketplace/orders` with the ids, the total and the request key. The wallets are now held for you for 30 minutes.
5. Send `amountRaw` to `paymentAddress`, on the order's chain, before `expiresAt`.
6. Follow the order with `GET /marketplace/orders/:id` until `status` is `fulfilled`. The answer then lists your new wallets.

:::warning You pay with real SOL or ETH
The payment is an on-chain transfer and cannot be undone. Pay the exact `amountRaw`, in one payment, before `expiresAt`. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Browse the wallets for sale

`GET /marketplace/inventory` lists wallets you can buy now, 100 per page. Every query field is optional. A filter you leave out matches every value, unless it has a default.

| Field | What it takes |
|---|---|
| `chain` | `solana` or `robinhood`. Default `solana`. |
| `kind` | `standard` or `dev`. Default `standard`. |
| `product` | `funded` or `aged`. Leave it out for both, and for dev wallets. |
| `tier` | `basic` or `premium`. |
| `traderProfile` | `us`, `eu` or `asia`. |
| `proTrader` | `pro` or `regular`. |
| `provider` | The exchange that first funded the wallet. See below. |
| `minAgeDays` | 0 to 3650. Only wallets funded at least this many days ago. Default `0`. |
| `sort` | `oldest` or `newest` funding first. Default `oldest`. |
| `offset` | 0 to 100000. Skip this many wallets. Default `0`. |
| `q` | Search text, up to 64 characters. See below. |

`provider` takes `binance`, `kucoin`, `bitget`, `bybit`, `gate`, `husher`, `changenow`, `sideshift`, or `unknown` for not recorded.

`q` searches the exchange name, the listing reference (like `BIN-20260917-001`), `#` plus the id, and the funding day.

An unknown field gets `400 validation_failed`.

The wallet types in the app map to these fields:

| In the app | Query |
|---|---|
| **Funded Solana** | `chain=solana&kind=standard&product=funded` |
| **Aged Solana** | `chain=solana&kind=standard&product=aged` |
| **Aged Robinhood** | `chain=robinhood&kind=standard&product=aged` |
| **Solana dev** | `chain=solana&kind=dev` |
| **Robinhood dev** | `chain=robinhood&kind=dev` |

**Pro traders** and **Regular** are `proTrader=pro` and `proTrader=regular`. Pro traders are aged Solana wallets only.

```bash
curl -s "https://evm.vortexdeployer.com/evm/api/v1/marketplace/inventory?chain=solana&kind=standard&product=aged&sort=newest" \
  -H "Authorization: Bearer vd_1a2b3c4d_…"
```

The answer:

```json
{
  "items": [
    {
      "id": "1042",
      "chain": "solana",
      "kind": "standard",
      "product": "aged",
      "proTrader": false,
      "tier": "basic",
      "traderProfile": "eu",
      "fundingMode": "cex",
      "fundedAt": "2026-09-17T08:12:00.000Z",
      "ageDays": 32,
      "balanceRaw": "41000000",
      "usdcRaw": "0",
      "priceRaw": "318000000",
      "includedBalanceRaw": "41000000",
      "warmupsDone": 0,
      "swapsDone": 14,
      "swapsTarget": 14,
      "fundingProvider": "binance",
      "blockedByLineage": false
    }
  ],
  "minAgeDays": 0,
  "total": 213,
  "providers": [ { "provider": "binance", "count": 120 }, { "provider": "unknown", "count": 93 } ],
  "devPricing": "twice_preparation_cost",
  "devCostMultiplier": 2,
  "agedMarkupBps": { "regular": 2800, "proTrader": 4400 }
}
```

- `id` — the listing id. You send it when you order.
- `priceRaw` — the full price of this wallet in [base units](https://vortexdeployer.com/docs/other/glossary#base-units): lamports on Solana, wei on Robinhood. It already includes the balance inside. `null` means the wallet cannot be priced right now. Skip it.
- `includedBalanceRaw` — the coins and USDC already in the wallet, counted in the chain's coin. They become yours. The wallet's own cost is `priceRaw` minus this.
- `balanceRaw`, `usdcRaw` — the SOL or ETH and the USDC inside, each in its own base units.
- `fundedAt`, `ageDays` — when the wallet was first funded, and how long ago.
- `fundingProvider` — the exchange that first funded it. `null` means not recorded. See [funding source](https://vortexdeployer.com/docs/other/glossary#funding-source).
- `swapsDone`, `swapsTarget` — trades made so far. An aged wallet has both above 0.
- `blockedByLineage` — `true` when it shares a funding source with a wallet you bought before. You cannot buy it.
- `total` — how many wallets match. Fetch the next page with `offset=100`, then `offset=200`.
- `providers` — how many matching wallets each exchange funded.

Prices move with the SOL or ETH rate. A wallet with USDC inside is priced at today's rate.

This list does not take `limit`. A `limit` gets `400 validation_failed`.

The wallet addresses stay hidden until you buy.

### Summary of one wallet type

`GET /marketplace/inventory/stats` takes `chain`, `kind`, `tier` and `product`, as above:

```json
{
  "chain": "solana",
  "kind": "standard",
  "tier": null,
  "updatedAt": "2026-10-19T12:00:00.000Z",
  "count": 213,
  "balanceRaw": { "avg": "39000000", "min": "1000000", "max": "120000000" },
  "swaps": { "avg": 12.4, "min": 8, "max": 20 },
  "fundingAgeDays": { "avg": 21.7, "min": 2.1, "max": 61.3 }
}
```

With nothing for sale, `count` is `0` and the other figures are `null`.

## Make an order

`POST /marketplace/orders`:

```json
{
  "chain": "solana",
  "ids": ["1042", "1043"],
  "expectedTotal": "636000000",
  "requestKey": "5b0e2a52-8a3f-4c1d-9a51-0f3c2b7d6e10"
}
```

- `chain` — `solana` or `robinhood`. Every id must be on this chain.
- `ids` — the listing ids you picked. At least one, each once.
- `expectedTotal` — the sum of the `priceRaw` you saw, as a whole number in a string.
- `requestKey` — a UUID you make for this order. See below.

No other field is allowed.

```bash
curl -s -X POST https://evm.vortexdeployer.com/evm/api/v1/marketplace/orders \
  -H "Authorization: Bearer vd_1a2b3c4d_…" \
  -H "Content-Type: application/json" \
  -d '{
    "chain": "solana",
    "ids": ["1042", "1043"],
    "expectedTotal": "636000000",
    "requestKey": "5b0e2a52-8a3f-4c1d-9a51-0f3c2b7d6e10"
  }'
```

It answers `201` with the order:

```json
{
  "id": "1a2b3c4d-5e6f-4a7b-8c9d-0e1f2a3b4c5d",
  "chain": "solana",
  "status": "pending",
  "amountRaw": "636000000",
  "receivedRaw": "0",
  "paymentAddress": "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin",
  "expiresAt": "2026-10-19T12:30:00.000Z",
  "collectedAt": null,
  "items": [
    { "id": "1042", "address": null, "kind": "standard", "priceRaw": "318000000", "fundedAt": "2026-09-17T08:12:00.000Z", "metadata": {}, "warmupsDone": 0, "walletId": null },
    { "id": "1043", "address": null, "kind": "standard", "priceRaw": "318000000", "fundedAt": "2026-09-18T10:40:00.000Z", "metadata": {}, "warmupsDone": 0, "walletId": null }
  ]
}
```

`amountRaw` is what you pay. The server prices the wallets again when you order. If its total is within about 1% of your `expectedTotal`, the order is made at the server's total. If not, you get `409` "The quote changed". List the wallets again and use the new prices.

### Request key: safe retries

The `requestKey` is how a retry stays safe. Send the same `requestKey` again and you get the same order back. No second order is made, even if the first answer never reached you. Use a new `requestKey` for each new order.

These calls take no `Idempotency-Key` header. The `requestKey` does that job. Leave the header off `…/check` in particular: with it, a repeat would return the first, saved answer instead of the order's status now.

### Rules for an order

- **One open order at a time.** While an order is `pending`, a new one gets `409` "Finish your pending marketplace order first". Pay it, or wait until it expires.
- **One wallet per funding source, ever.** Wallets first funded from the same wallet can be bought together, in one order. Once you have bought one of them, the others are refused in later orders. Check `blockedByLineage` before you pick.
- **Funding gap.** The app's **Quick select** keeps your picks a set time apart, so they do not look related. The API does not check this. If you want it, compare `fundedAt` yourself.
- **Sandbox keys cannot order.** An order has no dry run, so a [sandbox key](https://vortexdeployer.com/docs/api/overview#limits-on-a-key) gets `403 sandbox_key`. It can still browse.

### When an order is refused

| Answer | What to do |
|---|---|
| `400 validation_failed` | The body is wrong. Fix what `details` names. |
| `403 insufficient_scope` | The key lacks `trade`. Use a key that has it. |
| `403 sandbox_key` | The key is a sandbox key. Use a key without sandbox. |
| `409 conflict`: "Finish your pending marketplace order first" | Pay or wait out your open order. |
| `409 conflict`: "One or more wallets are no longer available. Refresh the marketplace." | Someone bought them first, or an id is wrong. List again and pick again. |
| `409 conflict`: "One or more wallets share a funding source with one of your previous purchases" | Pick only wallets whose `blockedByLineage` is `false`. |
| `409 conflict`: "The quote changed. Refresh prices before purchasing." | List again and send the new total. |

All four `409` answers share the code `conflict`. Tell them apart by the `error` text.

## Pay

Send exactly `amountRaw` to `paymentAddress`:

- in the chain's own coin: SOL on Solana, ETH on Robinhood. Not USDC.
- `amountRaw` is in lamports on Solana and in wei on Robinhood.
- before `expiresAt`, 30 minutes after the order was made.
- in one payment, from any wallet: a wallet in your account, an exchange or your own.

A payment a little short, up to about $1, still counts. An exchange's withdrawal fee can take more than that, so check what will arrive.

:::warning After the order expires, do not pay
When `expiresAt` passes unpaid, the wallets go back on sale. Never send to that payment address again.
:::

## Follow the order

`GET /marketplace/orders/:id` answers the same order shape as above. The marketplace looks for payments every 15 seconds by itself. Ask every 15 to 30 seconds until the status changes.

`POST /marketplace/orders/:id/check` looks for your payment right away, then answers the order. Call it once after you pay, to skip the wait. It is also how you report a late payment on an expired order.

Each check counts as a read toward your [rate limit](https://vortexdeployer.com/docs/api/limits-errors#rate-limits), the same as a `GET`. Making an order does not count.

`status` is one of:

| `status` | What it means |
|---|---|
| `pending` | Waiting for your payment. In the app: **Awaiting payment**. |
| `fulfilled` | Paid. The wallets are yours. In the app: **Delivered**. |
| `expired` | Time ran out with no payment. The wallets went back on sale. In the app: **Expired**. |
| `refund_required` | Paid too late or too short. Ask [Support](https://vortexdeployer.com/docs/account/support) with the order `id`. In the app: **Needs review**. |

- `receivedRaw` — what has arrived at the payment address so far.
- `collectedAt` — when the marketplace moved your payment on. You can ignore it.

An order `id` that is not yours, or not a UUID, gets `404 not_found`.

## Where your wallets land

When an order is `fulfilled`, each item gets its `address` and `walletId`. The wallets are now in your account, in your [wallet pool](https://vortexdeployer.com/docs/other/glossary#wallet-pool):

- Each order gets its own new folder, **Marketplace #** plus the first 8 characters of the order `id`, for example **Marketplace #1a2b3c4d**. If you already have a folder with that name, the full order id is used. If neither works, the wallets arrive outside any folder.
- Dev wallets get the `dev` role. All others get `trading`.
- Each wallet is labelled "Marketplace" plus its kind and listing id, for example "Marketplace standard #1042".

Find them with `GET /wallets`, like any other wallet. See [Wallets, portfolio & PnL](https://vortexdeployer.com/docs/api/wallets-pnl). A new wallet's balance may take a moment to show.

No call returns a bought wallet's [private key](https://vortexdeployer.com/docs/other/glossary#private-key). To export keys, use the app with your password. See [Export a private key](https://vortexdeployer.com/docs/wallets/key-export).

An item's `metadata` holds notes from when the wallet was prepared. Do not build on it: its fields can change.

## Your orders

`GET /marketplace/orders` answers your last 50 orders, newest first:

```json
{
  "orders": [
    { "id": "1a2b3c4d-5e6f-4a7b-8c9d-0e1f2a3b4c5d", "chain": "solana", "status": "fulfilled", "amountRaw": "636000000", "createdAt": "2026-10-19T12:00:00.000Z" }
  ]
}
```

It takes `?limit=` and `?offset=`. `X-Total-Count` holds the full count. See [Paging](https://vortexdeployer.com/docs/api/limits-errors#paging).

## What stays in the app

- The marketplace operator's admin view.
- The launch info files dev wallets were made with.

## See also

- [Wallet Marketplace](https://vortexdeployer.com/docs/wallets/marketplace) — the same thing in the app.
- [Wallets, portfolio & PnL](https://vortexdeployer.com/docs/api/wallets-pnl)
- [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors)
- [MCP for AI agents](https://vortexdeployer.com/docs/api/mcp)

---

# Account settings & KOLs

> Read and change your sell setting and your tracked KOL wallets from code, and see what stays in the app.

Source: https://vortexdeployer.com/docs/api/account · Markdown: https://vortexdeployer.com/docs/api/account.md

Two account settings are on the API: how your sells are sent, and the KOL wallets you track. Reads need the `read` [scope](https://vortexdeployer.com/docs/other/glossary#scope). Changes need `trade`.

## Sell through another wallet

This setting can send a sale through a [temporary wallet](https://vortexdeployer.com/docs/other/glossary#temporary-wallet). Your tokens move to a fresh wallet, that wallet sells, and the money comes back to you. On Solana each such sale is two transactions: one sends 0.01 SOL and the tokens to the temporary wallet, the other sells and sends all the SOL back. You pay network fees on both.

In the app this is **Sell through another wallet** on the [Settings](https://vortexdeployer.com/docs/account/settings) page.

`GET /settings/trading`:

```json
{
  "sellThroughTemporaryWallet": true,
  "temporarySellMode": "custom",
  "temporarySellManual": {
    "simple": true, "uniqueWallet": false, "percentage": false, "sellAll": true,
    "sellAllExceptDev": true, "sellDev": false, "tradePanel": false
  },
  "temporarySellTasks": true,
  "temporarySellTaskTypes": { "volume": true, "dca": false, "…": true }
}
```

- `temporarySellMode` — `off`, `all` (every sale) or `custom` (only the switches that are on).
- `temporarySellManual` — one switch per kind of sale you make by hand. A sell sent through the API counts as `simple`.
- `temporarySellTasks` — whether task sells use it.
- `temporarySellTaskTypes` — one switch per task type: `volume`, `warmup`, `antisniper`, `handswitcher`, `fakevolume`, `limit_order`, `ladder`, `mirror`, `dca` and `trailing_stop`.
- `sellThroughTemporaryWallet` — `true` whenever the mode is not `off`.

### Change it

`PATCH /settings/trading` takes one of two bodies.

The simple switch:

```json
{ "sellThroughTemporaryWallet": true }
```

`true` sets the mode to `all`. `false` sets it to `off`.

Or the full setting, with every field:

```json
{
  "temporarySellMode": "custom",
  "temporarySellManual": { "simple": true, "uniqueWallet": false, "percentage": false, "sellAll": true, "sellAllExceptDev": true, "sellDev": false, "tradePanel": false },
  "temporarySellTasks": false
}
```

`temporarySellTaskTypes` is optional here. The answer is the setting after the change. It applies to every sell after that.

## Tracked wallets (KOLs)

A [KOL](https://vortexdeployer.com/docs/other/glossary#kol) is a well-known trader. The terminal marks the wallets you track. See [KOL tracker](https://vortexdeployer.com/docs/terminal/kol-tracker).

| Call | Scope | What it does |
|---|---|---|
| `GET /kols` | `read` | Your tracked wallets. Paged with `?limit=` and `?offset=`. |
| `POST /kols` | `trade` | Track a wallet. |
| `PATCH /kols/:address` | `trade` | Change its name or emoji. |
| `DELETE /kols/:address` | `trade` | Stop tracking it. |

`POST /kols`:

```json
{ "address": "7tXi4mbvppPBgYgTVj2NpYq9K1KYYQvHv6tfCpJv9kMT", "name": "Whale 1", "emoji": "🐳" }
```

- `address` — 32 to 44 characters.
- `name` — up to 64 characters. Optional.
- `emoji` — up to 8 characters. Optional.

It answers `201` with `{ "kol": { … } }`. Adding an address you already track updates its name and emoji.

`PATCH /kols/:address` takes `name` and `emoji`; `null` clears one. It answers `{ "kol": { … } }`.

`DELETE /kols/:address` answers `{ "removed": "7tXi…" }`.

An address you do not track gets `404`.

## What stays in the app

- **API keys.** You make, edit and revoke keys only in the app, while signed in. An API key cannot make keys.
- **Private keys.** No API call returns a wallet's private key.
- **Your login, account profile, referrals and support tickets.** These are app-only.

The Wallet Marketplace is on the API. See [Wallet marketplace](https://vortexdeployer.com/docs/api/marketplace).

## See also

- [API overview & keys](https://vortexdeployer.com/docs/api/overview)
- [Settings](https://vortexdeployer.com/docs/account/settings)
- [KOL tracker](https://vortexdeployer.com/docs/terminal/kol-tracker)
- [Buy, sell & batches](https://vortexdeployer.com/docs/api/trading)

---

# Live streams

> Get live trades, PnL, wallet balances and task changes over one WebSocket with your API key.

Source: https://vortexdeployer.com/docs/api/streams · Markdown: https://vortexdeployer.com/docs/api/streams.md

A [WebSocket](https://vortexdeployer.com/docs/other/glossary#websocket) is a connection that stays open, so the server can push news to you the moment it happens. Use it instead of asking a REST route again and again.

## Before you start

- Connect to `wss://evm.vortexdeployer.com/evm/ws`. API keys work only at this address.
- Your key needs the right [scope](https://vortexdeployer.com/docs/other/glossary#scope) for each topic. See [Topics](#topics).
- Run this from a server. Never open a keyed socket in a web page: anyone could read the key there.

## Connect and subscribe

Every message is one JSON object. Put your key in `token` on each `subscribe`.

```js
const ws = new WebSocket('wss://evm.vortexdeployer.com/evm/ws');
ws.onopen = () => {
  ws.send(JSON.stringify({ type: 'subscribe', topic: 'txs:7xKX…pump', token: 'vd_…' }));
  setInterval(() => ws.send(JSON.stringify({ type: 'ping' })), 25_000);
};
ws.onmessage = (m) => console.log(JSON.parse(m.data));
```

What you send:

- `{ "type": "subscribe", "topic": "…", "token": "vd_…" }` — start a topic. The answer is `{ "type": "subscribed", "topic": "…" }`, then the topic's first frame.
- `{ "type": "unsubscribe", "topic": "…" }` — stop a topic. The answer is `{ "type": "unsubscribed", "topic": "…" }`.
- `{ "type": "ping" }` — the server answers `{ "type": "pong" }`. Use it to check the line is alive.

When you connect, the server sends `{ "type": "welcome", "topics": [ … ] }`. That list also holds topics the app uses. Only the topics below take an API key.

A refused subscribe answers `{ "type": "error", "topic": "…", "message": "…" }`. The message says why, such as a missing scope.

## Topics

| Topic | Scope | What you get |
|---|---|---|
| `txs` | `stream` | Every trade the platform sees, on every token. |
| `txs:<mint>` | `stream` | Trades on one token. |
| `pnl` | `stream` | Your [PnL](https://vortexdeployer.com/docs/other/glossary#pnl) on every token, on Solana. |
| `pnl:<mint>` | `stream` | Your PnL on one token. |
| `wallet:<address>` | `stream` | The live balance of one of your wallets. |
| `tasks` | `read` | Your running tasks, then every task change. |
| `user` | `read` | A nudge when something in your account changed. |

`<mint>` is the token's [mint address](https://vortexdeployer.com/docs/other/glossary#mint-address). Any other topic with a key, like `xid`, is refused.

## Trades

`txs` sends every trade as it lands. It starts with `{ "type": "txs_snapshot", "topic": "txs", "note": "firehose: deltas only" }`, then one `trade` frame per trade.

`txs:<mint>` starts with `{ "type": "trade_snapshot", "topic": "txs:<mint>", "mint": "…", "trades": [ … ] }`. That list holds the token's recent trades. Then new trades follow.

```json
{
  "type": "trade",
  "chain": "solana",
  "mint": "NnLz6wXfB3c41KwPWPvk9Rz75zR5enTGtYmsELrpump",
  "quote_mint": "So11111111111111111111111111111111111111112",
  "pool_address": "B8GeyGLChfj3Mn9HCyVJYS4nMRSMVDCCutRTwGasoH7V",
  "dex": "pump_swap",
  "side": "buy",
  "trader": "A2uqWi4Zm3yVYqvuRb4GF6BSb56pocvw1J2V2nQeU3QE",
  "base_amount": "44917",
  "quote_amount": "179054",
  "signature": "42RU7t2Drzyr…faT22",
  "block": 447482805,
  "block_index": 805,
  "timestamp": 1789549114,
  "pre_base_reserves": "2105102154648",
  "pre_quote_reserves": "8391614579937",
  "post_base_reserves": "2105102109731",
  "post_quote_reserves": "8391614758991"
}
```

:::info Stream frames use snake_case
Frames keep the chain feed's names, like `pool_address` and `block_index`. Only REST answers use camelCase.
:::

| Field | Meaning |
|---|---|
| `mint` | The token that was traded. |
| `quote_mint` | What it was traded against, like wrapped SOL. |
| `pool_address`, `dex` | The [pool](https://vortexdeployer.com/docs/other/glossary#pool) and the venue, like `pump_swap`. |
| `side` | `buy` or `sell`. |
| `trader` | The wallet that traded. |
| `base_amount`, `quote_amount` | The two amounts, as strings in [base units](https://vortexdeployer.com/docs/other/glossary#base-units). |
| `signature`, `block`, `block_index`, `timestamp` | Where it landed on the chain. `timestamp` is in Unix seconds. |
| `pre_…_reserves`, `post_…_reserves` | What the pool held just before and just after. `null` when the venue does not say. |

The reserves let you work out the pool's price without another call.

## PnL

A `pnl:<mint>` frame:

```json
{ "type": "pnl_update", "topic": "pnl:7xKX…pump", "mint": "7xKX…pump", "at": 1757923203112, "pnl": { } }
```

- `pnl` has the same fields as `GET /pnl?mint=`. It is `null` when the token cannot be priced, and `reason` says why.
- On `pnl` with no mint, the frame has `chain` and `tokens` instead. `tokens` matches `GET /pnl`.
- `at` is a time in milliseconds. It only goes up. Drop a frame whose `at` is not newer than the last one.
- A frame comes at most once every 3 seconds per topic.
- A frame with `error` means the PnL cannot be worked out right now.

## Wallet balances

`wallet:<address>` must name one of your own wallets. A key with a wallet list can open only wallets on that list. Any other address is refused.

You get a `wallet_balance_snapshot` first, then a `wallet_balance_update` each time the balance changes:

```json
{
  "type": "wallet_balance_update",
  "chain": "solana",
  "address": "7tXi4mbvppPBgYgTVj2NpYq9K1KYYQvHv6tfCpJv9kMT",
  "sol": "420100000",
  "tokens": [ { "mint": "7xKX…pump", "amount": "3500000000" } ],
  "block": 447482806,
  "block_index": 806
}
```

- `sol` — the coin balance as a string in base units: lamports on Solana, wei on an EVM chain.
- `tokens` — the token balances it tracks, each `mint` and `amount` in base units.
- `block`, `block_index` — where the balance was last seen. `block_index` can be `null`.

If no balance is saved yet, you get `{ "type": "wallet_balance_pending", "topic": "…" }` first. The server reads the balance and sends an update.

To track one token from the start, add `mint` to the subscribe: `{ "type": "subscribe", "topic": "wallet:<address>", "mint": "7xKX…pump", "token": "vd_…" }`.

## Tasks

`tasks` starts with your running and paused tasks:

```json
{ "type": "task_snapshot", "topic": "tasks", "tasks": [ { "task_id": "6186", "task_type": "buy", "mint": "7xKX…pump", "status": "running", "label": "morning buys", "updated_at": "2026-09-16T01:09:24.531Z" } ] }
```

Then it sends three kinds of frames:

- `task_update` — a task's status changed. It has `task_id`, `task_type`, `mint`, `status`, `last_error` and `updated_at`.
- `task_execution` — a task sent a trade. It has `task_id` and an `execution` with `id`, `side`, `wallet_id`, `amount_in`, `amount_out`, `signature`, `confirmed`, `err`, `source` and `created_at`.
- `wallet_skipped` — a task left a wallet out. It has `task_id`, `wallet_id`, `mint`, `reason`, `source` and `timestamp`.

See [Tasks API](https://vortexdeployer.com/docs/api/tasks) for what each status means.

## Account nudges

`user` starts with `{ "type": "user_snapshot", "topic": "user", "note": "deltas only; re-read your REST resources now" }`. Read what you need over REST at that point.

After that you get:

- `{ "type": "invalidate", "resource": "wallets", "id": null }` — that part of your account changed. Read it again over REST. `resource` names it, like `wallets` or `portfolio`.
- `{ "type": "launch", … }` — a launch moved on. `stage` is `prepared`, `confirmed`, `unsettled` or `failed`. The frame also has `launch_id`, `project_id`, `mint`, `signature` and `err`.

## Rules and limits

- **One key per socket.** After the first keyed subscribe, a different key on the same socket is refused.
- **5 sockets per key.** A sixth socket gets an error on its first subscribe.
- **50 `txs`/`pnl` topics and 50 `wallet` topics per socket.**
- **4 subscribes waiting at once.** Wait for answers before you send more.
- The key's IP list applies to sockets too.
- A message you send can be up to 4,096 bytes.
- Keys cannot use the socket for reads. Use REST.

These close the socket:

| Code | Why |
|---|---|
| `4001` | The key was revoked, or its settings changed. Reconnect with a valid key. |
| `4008` | 10 subscribes failed with a bad key. The next subscribe closes the socket. |
| `1013` | Too many sockets from your IP address. |

## Slow readers and reconnects

If you read too slowly, the server drops frames for you. When you catch up, it sends `{ "type": "resync", "topic": "…" }` and then a fresh first frame for that topic. Treat it like a new start and read missed state over REST.

A drop loses your topics. Reconnect with a short, growing wait, then subscribe again.

## See also

- [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors)
- [Tasks API](https://vortexdeployer.com/docs/api/tasks)
- [Wallets, portfolio & PnL](https://vortexdeployer.com/docs/api/wallets-pnl)
- [MCP for AI agents](https://vortexdeployer.com/docs/api/mcp)

---

# Limits, retries & errors

> How many calls you may make, how to retry without paying twice, and what every error answer means.

Source: https://vortexdeployer.com/docs/api/limits-errors · Markdown: https://vortexdeployer.com/docs/api/limits-errors.md

This page covers the rules every call shares: rate limits, safe retries, paging and errors. The base address is `https://evm.vortexdeployer.com/evm/api/v1`.

## Rate limits

A [rate limit](https://vortexdeployer.com/docs/other/glossary#rate-limit) caps how many calls you make per minute. Only reads count. Checking a marketplace order counts as a read too.

| Calls | Per key | Per account |
|---|---|---|
| `GET` and `HEAD`, and an order check | 300 a minute | 600 a minute |
| Every other `POST`, `PATCH`, `DELETE` | no limit | no limit |

An order check is `POST /marketplace/orders/:id/check`. It moves no funds and only reads where your order stands, so it counts like a `GET`. See [Wallet marketplace](https://vortexdeployer.com/docs/api/marketplace#follow-the-order).

All the keys on one account share the account's 600. Buys, sells, batches and launches have no per-minute limit. Neither does making a marketplace order. A key's caps and wallet list guard spending instead. See [API overview & keys](https://vortexdeployer.com/docs/api/overview).

Each read answer, an order check too, has three headers about the key's minute:

| Header | Meaning |
|---|---|
| `X-RateLimit-Limit` | Reads a minute the key allows. |
| `X-RateLimit-Remaining` | Reads left this minute. |
| `X-RateLimit-Reset` | When the count starts again, in Unix seconds. |

Over the limit, you get `429` and a `Retry-After` header in seconds. The body has the same number:

```json
{ "code": "rate_limited", "error": "rate limit reached — slow down", "retryAfterSeconds": 12, "traceId": "…" }
```

Wait that many seconds, then go on.

Bad keys count too. After 30 calls with a wrong or revoked key from one IP address in a minute, every call from it gets `429 auth_rate_limited` for a minute.

## Retry safely

A network can drop the answer after the work is done. If you just send the call again, you may buy twice.

An [idempotency key](https://vortexdeployer.com/docs/other/glossary#idempotency-key) stops that. It is a name you pick for one operation, sent in the `Idempotency-Key` header. Send the same name again and the API answers from its record. It does not run the work twice.

```bash
curl -s -X POST https://evm.vortexdeployer.com/evm/api/v1/buy \
  -H "Authorization: Bearer vd_…" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: buy-7xKX-2026-10-18-0001" \
  -d '{ "mint": "7xKX…pump", "walletId": "812", "amountSol": 0.05 }'
```

- Use one on every `POST`, `PATCH` and `DELETE` that moves money: buys, sells, batches, launches, claims and tasks.
- A Wallet Marketplace order uses its own `requestKey` instead. See [Request key: safe retries](https://vortexdeployer.com/docs/api/marketplace#request-key-safe-retries).
- It is 8 to 128 characters: letters, digits, `-`, `_` and `:`. Anything else gets `400 invalid_idempotency_key`.
- Make it unique per operation. A new trade needs a new key.
- Keys belong to your account. Two of your API keys share them.
- The answer echoes the key in the `x-idempotency-key` header.

:::warning A retry without the header is a new trade
Without `Idempotency-Key`, sending a buy again buys again.
:::

### What a repeat returns

| You send | You get |
|---|---|
| The same key and the same body, after the first call ended | The first call's status and body. Nothing runs again. |
| The same key and body while the first call still runs | The API waits about 5 seconds. Then it answers, or gives `409 operation_pending`. |
| The same key with a different body | `409 idempotency_conflict`. |

A repeated answer has an `x-operation-state` header:

- `complete` — the operation is over. Its `confirmed` and `err` fields show the chain's latest word.
- `pending` — a transaction is still on its way. Ask again later with the same key.

`operation_pending` carries `"operationId"` (your key) and `"pending": true`. The first call's transaction is never sent twice. Wait a few seconds and ask again with the same key.

### Same key or new key?

- **You got no answer** (a timeout or a dropped line): send again with the **same** key and body.
- **You got an answer, even an error:** that answer is saved under the key. To try again with a fixed body, use a **new** key.

A long call can be cut off after about 100 seconds before its answer reaches you. The work goes on. Ask again with the same key to get the result.

## Paging

Long lists are paged with `?limit=` and `?offset=`.

- `limit` is 1 to 500. Default 200.
- `offset` starts at 0.
- `X-Total-Count` holds the full size of the list.
- A `limit` out of range gets `400 validation_failed`.

A few lists page in their own way, like `GET /events` and `GET /marketplace/inventory`. Their pages say so.

## Errors

Every error is JSON with the same fields:

```json
{ "code": "insufficient_scope", "error": "this API key does not have the 'trade' scope", "traceId": "9f1c…" }
```

- `code` — a fixed name for the problem. Your code should check this.
- `error` — words for people. The wording can change.
- `traceId` — a [trace id](https://vortexdeployer.com/docs/other/glossary#trace-id) for this one call. Give it to support when you ask for help.

A bad body or query gets `validation_failed`, and `details` lists each problem:

```json
{
  "code": "validation_failed",
  "error": "validation failed",
  "details": [ { "path": "amountSol", "message": "Too small: expected number to be >0" } ],
  "traceId": "…"
}
```

Some codes add a field that names the limit:

- `over_trade_cap` adds `maxSolPerTrade`.
- `over_daily_cap` adds `dailySolCap`.
- `wallet_not_allowed` adds `walletId`.
- `rate_limited` and `auth_rate_limited` add `retryAfterSeconds`.

A route that does not exist gets `404 not_found` with "no such API route".

### Codes

| Code | Status | What it means and what to do |
|---|---|---|
| `validation_failed` | `400` | The body or query is wrong. Fix what `details` names. |
| `invalid_idempotency_key` | `400` | The `Idempotency-Key` header is malformed. |
| `bad_request` | `400` | The API understood the call but will not do it. `error` says why. |
| `invalid_api_key` | `401` | The key is missing, wrong or revoked. Stop and tell the key's owner. |
| `unauthorized` | `401` | A `401` with no other code. Treat it like `invalid_api_key`. |
| `insufficient_scope` | `403` | The key lacks the [scope](https://vortexdeployer.com/docs/other/glossary#scope) this route needs. |
| `ip_not_allowed` | `403` | The call came from an IP address the key does not allow. |
| `key_restricted` | `403` | A key with limits tried something only a key with no limits may do. |
| `sandbox_key` | `403` | A sandbox key sent a real call. Add `"dryRun": true`. |
| `wallet_not_allowed` | `403` | The wallet is not on the key's wallet list. |
| `private_key_not_allowed` | `403` | A key with a wallet list sent a private key. |
| `over_trade_cap` | `403` | A buy is over the key's max per buy. |
| `over_daily_cap` | `403` | The buy would pass the key's daily cap. |
| `forbidden` | `403` | The thing you named is not yours, or you may not do this. |
| `not_found` | `404` | No such route, or no such item in your account. |
| `idempotency_conflict` | `409` | You used this `Idempotency-Key` for a different body. |
| `operation_pending` | `409` | The first call with this key still runs. Ask again with the same key. |
| `conflict` | `409` | The call does not fit the current state, like pausing a stopped task. |
| `payload_too_large` | `413` | The body is too big. Most routes take up to 256 KB, `POST /launch` 15 MB and task calls 10 MB. |
| `unprocessable` | `422` | It cannot be done, like selling a token the wallet does not hold. |
| `rate_limited` | `429` | Too many reads. Wait `Retry-After` seconds. |
| `auth_rate_limited` | `429` | Too many bad keys from your IP address. Wait a minute. |
| `internal_error` | `500` | Something broke on our side. Note the `traceId`. |
| `service_unavailable` | `503` | Out of service for a moment. Wait, then ask again. |

A route may also send a code that is not listed here. Then go by the status.

A `503` with `operation_pending` means the work ran but its answer was not saved. Ask again later with the same key. Do not send it as new.

Each route's statuses and codes are in the OpenAPI document at `https://evm.vortexdeployer.com/evm/api/v1/openapi.json`.

## Ask for a feature

Missing an endpoint, field or stream? In the app, open **API** and then the **Feature requests** tab. Fill in **Request title** and **Request details**, then click **Send request**. Your requests and their status show in the same tab.

## See also

- [API overview & keys](https://vortexdeployer.com/docs/api/overview)
- [Buy, sell & batches](https://vortexdeployer.com/docs/api/trading)
- [Live streams](https://vortexdeployer.com/docs/api/streams)
- [Build an agent on the API](https://vortexdeployer.com/docs/api/agents)

---

# MCP for AI agents

> Connect Claude, Cursor or any MCP client to VortexDeployer so it can trade, launch, run tasks and read PnL with your API key.

Source: https://vortexdeployer.com/docs/api/mcp · Markdown: https://vortexdeployer.com/docs/api/mcp.md

[MCP](https://vortexdeployer.com/docs/other/glossary#mcp) (Model Context Protocol) is a standard way for AI assistants to call tools. VortexDeployer runs an MCP server. Each REST call is one tool, with the same scopes and limits.

| What | Value |
|---|---|
| Address | `https://evm.vortexdeployer.com/evm/api/v1/mcp` |
| How it talks | Streamable HTTP, stateless. Each request is a `POST` and gets a plain JSON answer. |
| Sign-in | `Authorization: Bearer vd_…`, the same [API key](https://vortexdeployer.com/docs/other/glossary#api-key) as REST. An OAuth token (`vdo_…`) works too. |
| Tools | 93, one per REST call. |

:::danger The assistant acts as you, with real money
Every tool runs as your account. `buy`, `sell` and `trade_batch` send real trades unless `dryRun` is `true`. Give the assistant its own key with only the [scopes](https://vortexdeployer.com/docs/other/glossary#scope) it needs. Set a max per buy and a daily cap on it. Start with a `read`-only key.
:::

## Before you start

- Make an API key in the app. See [API overview & keys](https://vortexdeployer.com/docs/api/overview).
- Pick its scopes: `read` to look, `trade` to trade and run tasks, `launch` to launch.

## Connect

**Claude Code:**

```bash
claude mcp add --transport http vortex https://evm.vortexdeployer.com/evm/api/v1/mcp \
  --header "Authorization: Bearer vd_…"
```

**Claude Desktop, Cursor and most other clients** take a JSON entry:

```json
{
  "mcpServers": {
    "vortex": {
      "url": "https://evm.vortexdeployer.com/evm/api/v1/mcp",
      "headers": { "Authorization": "Bearer vd_…" }
    }
  }
}
```

**Claude.ai** cannot send a fixed key. Add a custom connector with the address `https://evm.vortexdeployer.com/evm/api/v1/mcp`. Claude then signs in through OAuth, and you pick which of your API keys it acts as. See [OAuth for connectors](https://vortexdeployer.com/docs/api/oauth).

**Your own code** can use any MCP SDK. With the TypeScript one:

```ts
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';

const client = new Client({ name: 'my-agent', version: '1.0.0' });
await client.connect(new StreamableHTTPClientTransport(new URL('https://evm.vortexdeployer.com/evm/api/v1/mcp'), {
  requestInit: { headers: { Authorization: 'Bearer vd_…' } },
}));
const { tools } = await client.listTools();
const me = await client.callTool({ name: 'me', arguments: {} });
```

Then ask in plain words, like _"Which of my wallets hold SOL?"_ or _"Dry-run a 0.1 SOL buy of this token from wallet 812."_ The assistant picks the tool and fills in the details.

## Tools

A tool's name is the call's `operationId` in the OpenAPI document at `https://evm.vortexdeployer.com/evm/api/v1/openapi.json`. Its arguments are the call's path and query fields plus its JSON body, all in one object.

For calls that take an `Idempotency-Key` header, pass it as the `idempotencyKey` argument. Do that on every trade. See [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors).

| Tools | REST calls | Scope |
|---|---|---|
| `me` | `GET /me` | any |
| `buy`, `sell`, `trade_batch` | `POST /buy`, `/sell`, `/trade/batch` | `trade` |
| `conversion_assets`, `conversion_quote` | `POST /convert/assets`, `/convert/quote` | `read` |
| `convert` | `POST /convert` | `trade` |
| `burn_tokens`, `lock_tokens` | `POST /tokens/burn`, `/tokens/lock` | `trade` |
| `creator_fees` / `claim_creator_fees` | `GET /tokens/creator-fees` / `POST …/claim` | `read` / `trade` |
| `launch` | `POST /launch` | `launch` |
| `upload_metadata` | `POST /launch/metadata` | `launch` |
| `list_launchpads`, `launch_quotes`, `launch_readiness`, `next_mint_address`, `clone_token_look`, `launch_affordability`, `supply_preview`, `pons_launch_terms`, `otcdesks_rewards` | `GET /launchpads…` and the `/launch/…` helpers | `read` |
| `list_supply_plans`, `mount_supply_plan` / `save_supply_plan`, `delete_supply_plan` | `/supply-plans…` | `read` / `trade` |
| `list_wallets`, `wallet_balances`, `token_balances`, `wallet_profile` | `GET /wallets…` | `read` |
| `create_wallets`, `update_wallet`, `delete_wallet`, `delete_wallets`, `move_wallets` | `POST`, `PATCH`, `DELETE /wallets…` | `trade` |
| `list_wallet_groups` / `create_wallet_group`, `rename_wallet_group`, `delete_wallet_group` | `/wallets/groups…` | `read` / `trade` |
| `list_cashback` / `claim_cashback` | `GET /wallets/cashback` / `POST …/claim` | `read` / `trade` |
| `portfolio`, `holdings`, `portfolio_pnl`, `daily_pnl`, `pnl`, `wallet_totals` | `GET /portfolio…`, `GET /pnl`, `POST /pnl/wallet-totals` | `read` |
| `list_projects`, `project_by_id`, `project_by_mint`, `project_wallets` | `GET /projects…` | `read` |
| `create_project`, `create_cto_project`, `update_project`, `delete_project`, `assign_project_wallets`, `remove_project_wallets`, `unlink_project_wallet`, `closeout_project` | `POST`, `PATCH`, `DELETE /projects…` | `trade` |
| `list_tasks`, `get_task`, `task_executions`, `task_postmortem`, `task_playbook`, `task_mixer_orders`, `task_disperse`, `preview_task` | `GET /tasks…`, `POST /tasks/:id/preview` | `read` |
| `create_task`, `update_task`, `delete_task`, `start_task`, `pause_task`, `resume_task`, `stop_task`, `stop_all_tasks`, `execute_mixer_recipient` | `POST`, `PATCH`, `DELETE /tasks…` | `trade` |
| `list_presets` / `save_preset`, `delete_preset` | `/tasks/presets…` | `read` / `trade` |
| `list_events`, `warmup_candidates` | `GET /events`, `/warmup/candidates` | `read` |
| `list_marketplace_inventory`, `marketplace_inventory_stats`, `list_marketplace_orders`, `get_marketplace_order` / `create_marketplace_order`, `check_marketplace_order` | `/marketplace…` | `read` / `trade` |
| `trading_settings` / `update_trading_settings` | `GET` / `PATCH /settings/trading` | `read` / `trade` |
| `list_kols` / `track_kol`, `update_kol`, `untrack_kol` | `/kols…` | `read` / `trade` |

Each tool carries hints for your client. `GET` tools are marked read-only. Every other tool is marked as one that changes things. Your client can use this to ask you before it runs such a tool.

Some tools have a [dry run](https://vortexdeployer.com/docs/other/glossary#dry-run) on by default: `launch`, `claim_cashback`, `closeout_project`, `burn_tokens`, `lock_tokens` and `convert`. Others are real by default: `buy`, `sell`, `trade_batch`, `claim_creator_fees` and every task you start.

## What a call returns

The result is the REST answer, as text and as `structuredContent`. `_meta` has the HTTP status and, on reads and order checks, the key's rate-limit window:

```json
{
  "content": [ { "type": "text", "text": "{ \"user\": { … }, \"key\": { … } }" } ],
  "structuredContent": { "user": { "id": "1", "username": "yourname" }, "key": { "id": "9", "name": "agent", "prefix": "5e6f7a8b", "scopes": ["read"], "settings": {}, "restricted": false } },
  "_meta": { "status": 200, "rateLimit": { "limit": 300, "remaining": 299, "reset": 1758050400 } }
}
```

A refusal has `"isError": true` and the same body as REST: `code`, `error` and `traceId`. Read the `code` before you retry. The codes are in [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors#codes).

```json
{ "isError": true, "content": [ { "type": "text", "text": "{ \"code\": \"insufficient_scope\", \"error\": \"this API key does not have the 'trade' scope\", \"traceId\": \"…\" }" } ] }
```

Two refusals come from the MCP server itself:

- `validation_failed` — an unknown tool, a missing path argument like `id`, an `idempotencyKey` on a tool that takes none, or an unknown argument on a tool with no body. On a tool with a body, extra arguments go into the body, and the REST route checks them.
- `service_unavailable` — the call gave no answer in 3 minutes. The work may still finish. Ask again with the same `idempotencyKey`.

## Good to know

- **Same rules as REST.** Each tool call is made as the REST call with your key. Scopes, key limits, rate limits and idempotency all apply.
- **No session.** Every request signs in on its own. A dropped line loses nothing.
- **Amounts.** On-chain amounts are in base units unless the field says otherwise. `amountSol` is a plain JSON number in the chain's coin: SOL on Solana, ETH on an EVM chain. For `burn_tokens` and `lock_tokens`, `amount` with `amountType: "tokens"` is a whole number of base units, like `"3500000000"`, never `"1.5"`. With `"percentage"` it is a whole number from 1 to 100. A bad amount comes back as `"ok": false` with the reason in `error`. See [Burn and lock](https://vortexdeployer.com/docs/api/trading#burn-and-lock).
- **Streams are not tools.** For live trades, PnL and balances, use [Live streams](https://vortexdeployer.com/docs/api/streams).
- **Usage** shows in the app on the **API** page, **Usage** tab, under the same key.
- A `GET` to `https://evm.vortexdeployer.com/evm/api/v1/mcp` gets `405`. Only `POST` works.

## See also

- [OAuth for connectors](https://vortexdeployer.com/docs/api/oauth)
- [Build an agent on the API](https://vortexdeployer.com/docs/api/agents)
- [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors)
- [Live streams](https://vortexdeployer.com/docs/api/streams)

---

# OAuth for connectors

> How Claude.ai and other MCP clients that cannot hold an API key connect to VortexDeployer through OAuth, and how a grant is tied to one of your keys.

Source: https://vortexdeployer.com/docs/api/oauth · Markdown: https://vortexdeployer.com/docs/api/oauth.md

Some MCP clients, like Claude.ai custom connectors, cannot send a fixed API key. They sign in with [OAuth](https://vortexdeployer.com/docs/other/glossary#oauth) instead. OAuth is a standard way for an app to get access to your account without ever seeing your password.

VortexDeployer runs an OAuth 2.1 server for these clients. It uses the authorization code flow with [PKCE](https://vortexdeployer.com/docs/other/glossary#pkce). At the end, the client holds an [access token](https://vortexdeployer.com/docs/other/glossary#access-token) that starts with `vdo_`. It works anywhere an [API key](https://vortexdeployer.com/docs/other/glossary#api-key) works: the [MCP server](https://vortexdeployer.com/docs/api/mcp), every REST route and the live streams.

| What | Address |
|---|---|
| Issuer | `https://evm.vortexdeployer.com/evm/api/v1` |
| Server info (RFC 8414) | `https://evm.vortexdeployer.com/.well-known/oauth-authorization-server` |
| Resource info (RFC 9728) | `https://evm.vortexdeployer.com/.well-known/oauth-protected-resource` |
| Register a client (RFC 7591) | `POST https://evm.vortexdeployer.com/evm/api/v1/oauth/register` |
| Ask for access | `GET https://evm.vortexdeployer.com/evm/api/v1/oauth/authorize` |
| Get tokens | `POST https://evm.vortexdeployer.com/evm/api/v1/oauth/token` |
| Revoke a token (RFC 7009) | `POST https://evm.vortexdeployer.com/evm/api/v1/oauth/revoke` |

The two `.well-known` files live at the root of the API host, not under `/api/v1`. They also answer with the resource path added at the end, like `https://evm.vortexdeployer.com/.well-known/oauth-protected-resource/api/v1/mcp`. Copies answer under `https://evm.vortexdeployer.com/evm/api/v1/oauth/.well-known/…` too.

## One grant, one key

When you approve a client, you pick one of your API keys. The grant is tied to that key. The client's token then acts as that key in every way:

- It has the key's [scopes](https://vortexdeployer.com/docs/other/glossary#scope), its max per buy, its daily cap, its wallet list and its IP list.
- It shares the key's rate limits.
- Its calls show under that key on the **API** page, **Usage** tab.
- Revoke the key and every token made from it stops working on its next call.

OAuth has no scopes of its own here. A `scope` value in the request is ignored.

:::warning Give the agent a small key
The agent spends real money as the key allows. Make a new key for it first. Use a `read`-only key to look around, or a `trade` key with a low max per buy and a daily cap. See [API overview & keys](https://vortexdeployer.com/docs/api/overview).
:::

## Connect Claude.ai

1. In the app, open **API** and make a key for the agent.
2. In Claude.ai, add a custom connector with the address `https://evm.vortexdeployer.com/evm/api/v1/mcp`.
3. Claude registers itself and sends you to the **Connect an AI agent** page. Sign in if asked.
4. The page names the app that asks and the site your browser returns to. Under **Act as this API key**, pick the key.
5. Click **Approve as** _key name_. To refuse, click **Deny**.

Claude's tools now act as that key. To end access, remove the connector in Claude.ai or revoke the key in the app.

If you have no active key, the page says **No active API keys**. Make one in the app, then connect again.

## Build an OAuth client

This part is for developers of MCP clients. The flow is plain OAuth 2.1, so the OAuth helpers in the MCP SDKs work as they are.

### 1. Find the server

Call `POST https://evm.vortexdeployer.com/evm/api/v1/mcp` with no token. The `401` answer has a header that points to the resource info:

```http
WWW-Authenticate: Bearer resource_metadata="https://evm.vortexdeployer.com/.well-known/oauth-protected-resource"
```

That file names the server in `authorization_servers`. Then read `https://evm.vortexdeployer.com/.well-known/oauth-authorization-server` for the addresses above. It lists `S256` as the only PKCE method and `none` as the only client sign-in method.

### 2. Register once

```http
POST https://evm.vortexdeployer.com/evm/api/v1/oauth/register
Content-Type: application/json

{ "client_name": "My agent", "redirect_uris": ["https://myapp.example/oauth/callback"] }
```

- `client_name` — up to 128 characters. Default `MCP client`.
- `redirect_uris` — 1 to 16 addresses your user comes back to. Each must be `https`, or `http` on `localhost`, `127.0.0.1` or `[::1]`. No `#` part.

The answer is `201` with your `client_id`. No client secret is given. Every client is public, and PKCE proves the code is yours.

### 3. Send the user to approve

Make a random `code_verifier`. Its `code_challenge` is base64url(sha256(verifier)), 43 characters. Then send the browser to:

```
https://evm.vortexdeployer.com/evm/api/v1/oauth/authorize?response_type=code
  &client_id=…&redirect_uri=…&state=…
  &code_challenge=…&code_challenge_method=S256
```

- `redirect_uri` must match a registered one exactly.
- `state` is optional, up to 1,024 characters. It comes back to you unchanged.
- A bad request answers `400` on the spot. It never sends the browser to your address.

The user then sees the **Connect an AI agent** page in the app. It stays open for 10 minutes. On approve, the browser comes back with `code` and `state`. On deny, it comes back with `error=access_denied`.

### 4. Trade the code for tokens

The body is form-encoded, up to 8 KB:

```http
POST https://evm.vortexdeployer.com/evm/api/v1/oauth/token
Content-Type: application/x-www-form-urlencoded

grant_type=authorization_code&code=…&redirect_uri=…&client_id=…&code_verifier=…
```

```json
{ "access_token": "vdo_…", "token_type": "Bearer", "expires_in": 3600, "refresh_token": "vdr_…" }
```

A code works once and lasts 2 minutes. The client, the redirect address and the verifier must all match.

### 5. Use and refresh

Send `Authorization: Bearer vdo_…` to `https://evm.vortexdeployer.com/evm/api/v1/mcp` or any REST route. On a stream, put it in `token` on each subscribe.

The access token lasts 1 hour. Before then, get a new pair:

```http
POST https://evm.vortexdeployer.com/evm/api/v1/oauth/token
Content-Type: application/x-www-form-urlencoded

grant_type=refresh_token&refresh_token=vdr_…&client_id=…
```

A [refresh token](https://vortexdeployer.com/docs/other/glossary#refresh-token) lasts 30 days and works once. Each refresh gives a new one. If an old refresh token is sent again, the server takes that as a leak. It revokes every token of that key and client, and the user must approve again.

### 6. Revoke

```http
POST https://evm.vortexdeployer.com/evm/api/v1/oauth/revoke
Content-Type: application/x-www-form-urlencoded

token=vdo_…
```

It always answers `200`, even for a token it does not know.

## Errors

These addresses answer in the OAuth style, not the API's usual shape:

```json
{ "error": "invalid_grant", "error_description": "the grant is invalid, expired or already used" }
```

| `error` | Status | When |
|---|---|---|
| `invalid_client_metadata` | `400` | The register body is wrong. |
| `invalid_redirect_uri` | `400` | A redirect address breaks the rules in step 2. |
| `invalid_request` | `400` | A field is missing or wrong, or the client or redirect address is unknown. |
| `invalid_grant` | `400` | The code or refresh token is wrong, expired, used, or sent with the wrong verifier. |
| `temporarily_unavailable` | `429` | Too many tries from your IP address. Wait a minute. |

The limits per IP address and minute:

- Register: 10 clients.
- Ask for access: 30 requests.
- Get tokens: failed tries share the API's budget for bad keys, 30 a minute. Over it, every call to `/oauth/token` gets `429` with `Retry-After: 60`.

## See also

- [MCP for AI agents](https://vortexdeployer.com/docs/api/mcp)
- [API overview & keys](https://vortexdeployer.com/docs/api/overview)
- [Live streams](https://vortexdeployer.com/docs/api/streams)
- [Build an agent on the API](https://vortexdeployer.com/docs/api/agents)

---

# Build an agent on the API

> How an AI agent finds the API, signs in with a key a person gives it, and trades safely with dry runs and retry keys.

Source: https://vortexdeployer.com/docs/api/agents · Markdown: https://vortexdeployer.com/docs/api/agents.md

This page is for AI agents and the people who build them. It shows where everything lives, how to sign in, and a safe way to trade. Every docs page is also plain Markdown: add `.md` to its address.

## Where everything is

| What | Where |
|---|---|
| `agents.txt` | `https://vortexdeployer.com/agents.txt` — one short file with the addresses, the key rules and what an agent may fetch on the site. |
| `llms.txt` | `https://vortexdeployer.com/llms.txt` — a list of every docs page with one line about each. API pages come first. |
| `llms-full.txt` | `https://vortexdeployer.com/llms-full.txt` — every docs page in one file. |
| A page as Markdown | Its address plus `.md`, like `https://vortexdeployer.com/docs/api/trading.md`. |
| API index | `GET https://evm.vortexdeployer.com/evm/api/v1` — JSON with the addresses in this table. No key needed. |
| [OpenAPI](https://vortexdeployer.com/docs/other/glossary#openapi) document | `https://evm.vortexdeployer.com/evm/api/v1/openapi.json` — every REST call with its `operationId`, fields and the scope it needs (`x-scope`). |
| MCP server | `https://evm.vortexdeployer.com/evm/api/v1/mcp` — the same calls as tools. See [MCP for AI agents](https://vortexdeployer.com/docs/api/mcp). |
| Live streams | `wss://evm.vortexdeployer.com/evm/ws` — trades, PnL, balances and tasks as they happen. See [Live streams](https://vortexdeployer.com/docs/api/streams). |

With only the REST address, an agent can read the index, fetch the OpenAPI document and start.

On the website, an agent may fetch `/docs`, `/docs/*.md`, `/llms.txt`, `/llms-full.txt`, `/agents.txt` and `/robots.txt`. The rest of the site is the signed-in app. Use the API for that.

## Sign in

A person makes an [API key](https://vortexdeployer.com/docs/other/glossary#api-key) in the app at `https://vortexdeployer.com/developers` and gives it to the agent. The key works until its owner revokes it.

- **REST and MCP:** send `Authorization: Bearer vd_…` on every call.
- **Streams:** put the key in `token` on each subscribe.
- **First call:** `GET https://evm.vortexdeployer.com/evm/api/v1/me`. It shows the key's [scopes](https://vortexdeployer.com/docs/other/glossary#scope), its max per buy, its daily cap, its wallet list and whether it is a sandbox key. Plan within these limits.

:::danger Never act as the person in the app
Do not sign in, register or click through the app for someone. Keys are made by a person and handed to you.
:::

The one exception is an MCP client that can only use OAuth, like a Claude.ai connector. It runs the [OAuth flow](https://vortexdeployer.com/docs/api/oauth), and the person picks a key on the consent page. The token then follows that key's rules.

A `401` means the key is gone or wrong. Stop, do not retry, and tell the key's owner.

## Trade safely

Every call acts as the key's owner, with real money.

- **Ask for the smallest key.** `read` to look and report. `trade` with a max per buy and a daily cap to trade. `launch` only to launch. `stream` only for live streams. See [API overview & keys](https://vortexdeployer.com/docs/api/overview).
- **Try it first.** Send `"dryRun": true` on `buy`, `sell` and `trade/batch`. A [dry run](https://vortexdeployer.com/docs/other/glossary#dry-run) runs every check and shows what would happen, but sends nothing. `POST /launch` is a dry run unless you send `"dryRun": false`.
- **Send an `Idempotency-Key`** on every buy, sell, batch and launch. An [idempotency key](https://vortexdeployer.com/docs/other/glossary#idempotency-key) is a name you choose for one operation. If the line drops, send the same call with the same key. You get the first answer back, never a second trade.
- **Expect long calls to be cut.** A launch or a batch that waits can take longer than the connection stays open, about 100 seconds. The work goes on. Ask again with the same key to get the result. A batch with long waits between wallets becomes a task and answers at once.
- **Watch the rate headers.** `X-RateLimit-Remaining` and `X-RateLimit-Reset` come on every read. A `429` has `retryAfterSeconds`. Wait that long.
- **Check `code`, not `error`.** `code` never changes. The `error` text is for people and can change.

:::warning Get amounts right
`amountSol` is a JSON number in the chain's coin, like `0.25`. Token amounts are strings in [base units](https://vortexdeployer.com/docs/other/glossary#base-units), like `"3500000000"`. A sell can use `percentage` instead. Never guess a token's decimals. Read them from the balance answers.
:::

## A loop that works

1. `GET /me` — what may this key do?
2. `GET /wallets` and `GET /wallets/balances` — which wallets, and what do they hold?
3. For a launch: `GET /launchpads`, then `GET /launchpads/:launchpad/quotes`. Copy the `quoteToken` and `pairToken` an entry gives.
4. Send the call with `"dryRun": true`. Show the person what would happen.
5. Send it for real with a new `Idempotency-Key`. If the answer gets lost, send it again with the same key.
6. Follow the result live with `txs:<mint>` and `pnl:<mint>` on the stream, instead of asking again and again.

Read [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors) for what each answer and error code means.

## MCP or REST?

- **MCP** suits assistants like Claude and Cursor. Each tool comes with its description and fields, so there is nothing to code. Read-only tools are marked as such.
- **REST** suits your own code. You can make a typed client in any language from the OpenAPI document.
- **Streams** are always the WebSocket. MCP has no stream tools.

## Get help

The key's owner can ask for help in the app at `https://vortexdeployer.com/support` or on Telegram at https://t.me/DeployOnVortexBot. Give support the `traceId` from the answer.

## See also

- [API overview & keys](https://vortexdeployer.com/docs/api/overview)
- [MCP for AI agents](https://vortexdeployer.com/docs/api/mcp)
- [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors)
- [Buy, sell & batches](https://vortexdeployer.com/docs/api/trading)

---

# API changelog

> Every change to the public API, newest first, and what to change in your code.

Source: https://vortexdeployer.com/docs/api/changelog · Markdown: https://vortexdeployer.com/docs/api/changelog.md

This page lists every change to the API, newest first. The version is in the address: `/api/v1`.

Inside v1, fields are only added. They are not removed or renamed, unless an entry here says so. Error `code` values stay the same. The `error` text can change.

## 2026-10-19 — Taking wallets out of a project never deletes them

**Changed**

- `DELETE /projects/:id/wallets/:walletId` and `POST /projects/:id/wallets/remove` no longer delete a wallet made inside the project. It moves to your pool, with its key and balance. `outcome` is always `unassigned`, and `deleted` is always empty. Both fields stay, so code that reads them keeps working. See [A project's wallets](https://vortexdeployer.com/docs/api/wallets-pnl#a-project-s-wallets).
- `DELETE /projects/:id` no longer deletes the project's wallets. They move to your pool. A wallet that another project also uses stays in that project.

## 2026-10-19 — The Wallet Marketplace is on the API

**Added**

- `GET /marketplace/inventory` lists the wallets for sale, with the app's filters, 100 per page. `GET /marketplace/inventory/stats` sums up one wallet type.
- `POST /marketplace/orders` reserves the wallets you pick and answers a payment address. Send a `requestKey` of your own: a retry with the same one returns the same order. A sandbox key gets `403 sandbox_key`.
- `GET /marketplace/orders/:id` and `POST /marketplace/orders/:id/check` follow an order until your wallets are delivered. A check counts as a read toward your rate limit, like a `GET`. `GET /marketplace/orders` lists your last 50 orders.
- New MCP tools: `list_marketplace_inventory`, `marketplace_inventory_stats`, `list_marketplace_orders`, `get_marketplace_order`, `create_marketplace_order` and `check_marketplace_order`.

An order moves no funds: you pay it yourself, from any wallet. So a key's max per buy, daily cap and wallet list do not apply. Reads need `read`; ordering and checking need `trade`. See [Wallet marketplace](https://vortexdeployer.com/docs/api/marketplace).

## 2026-10-17 — Launch tasks follow the same rules as other tasks

**Added**

- `tokendisperser` can be a launch task `type` on `POST /launch`.
- A `limit_order` launch task can pick its wallets with `walletSource` (`all` or `roles`) and an empty `walletIds`, as on `POST /tasks`. A key with a wallet list cannot do this.

**Changed**

- A launch task is now checked before the launch starts, with the same rules as `POST /tasks`: its wallets, its settings and the task type's own limits. Before, such a launch went ahead and its answer held a task `error`. Now it gets `400` before anything is funded or minted. See [Launch tasks](https://vortexdeployer.com/docs/api/launch#launch-tasks).
- Buy and Snipe launch tasks leave out the creator wallet, as tasks made after a launch do. It stays in only if it is the one wallet picked, or `config.includeDev` is `true`. On an EVM launch the creator no longer counts toward the cap on instant buyers. `POST /launch/affordability` no longer counts a buy from it.

## 2026-10-08 — Bulk wallet calls, up to 1,000 wallets each

**Added**

- `POST /wallets/delete` deletes many wallets in one call. A wallet a task uses, or a project still holds, is listed in `active` or `assigned`. The rest of the call goes on. See [Delete wallets](https://vortexdeployer.com/docs/api/wallets-pnl#delete-wallets).
- `POST /wallets/move` moves many wallets into a group, or out of one.
- `POST /projects/:id/wallets/remove` takes many wallets out of a project.
- `labelStart` on `POST /wallets` sets the number for the first new wallet's label. A set of wallets made over several calls keeps one count.
- New MCP tools for these: `delete_wallets`, `move_wallets` and `remove_project_wallets`.

**Changed**

- **One call takes up to 1,000 wallets.** This counts for `count` and `privateKeys` on `POST /wallets`, and for `walletIds` on the three new calls. A longer list gets `400`. Send the rest in a second call. Your account still has no wallet limit.

## 2026-10-08 — Creator fees: unswept fees, and claims the wallet cannot pay for

**Added**

- In `GET /tokens/creator-fees`, a venue has `unswept` when part of `claimable` still sits on the pump.fun bonding curve or the PumpSwap pool. The claim collects it in the same transaction. See [Creator fees](https://vortexdeployer.com/docs/api/trading#creator-fees).

**Changed**

- `POST /tokens/creator-fees/claim` now refuses a claim the creator wallet cannot pay for, before anything is sent. A dry run checks it too. The wallet must hold the network fee plus rent for each new token account the claim opens. The answer is `ok: false`, and `error` says how much SOL to add. Before, such a claim was sent and failed on the chain.

## 2026-09-21 — No caps on counts; slow sell batches become a task

**Changed**

- **No more caps on how many.** `POST /trade/batch` takes any number of `walletIds` (it was 500). `POST /wallets` takes any `count` and any number of `privateKeys` (both were 100), into a project of any size (it was 100). `POST /projects/:id/wallets/assign` takes any number of `walletIds` (it was 500). The server still splits the work to fit each transaction. _The 2026-10-08 entry later set 1,000 per call on the wallet calls._
- **A slow batch becomes a task, for buys and sells.** If the waits add up to over 60 seconds, a sell batch used to get `400`. Now it answers `202` with a task, like a buy batch. That task's `type` is `batch` (it was `buy`). A slow buy batch still needs real amounts: `token_percentage` gets `400`. See [Slow batches become a task](https://vortexdeployer.com/docs/api/trading#slow-batches-become-a-task).

## 2026-09-19 — A new address, and no limits on writes

**Changed**

- **The API moved to its own address:** `https://evm.vortexdeployer.com/evm/api/v1` for REST and `wss://evm.vortexdeployer.com/evm/ws` for streams. The old address on the app's dev host was shut the same day. Calls there now get `404` with the new address. Update your settings.
- **Writes have no rate limit now.** Buys, sells, batches and launches have no per-minute cap, per key or per account. Only reads (`GET`) are limited: 300 a minute per key and 600 per account. The `X-RateLimit-*` headers come on read answers only. If you spaced out trades for the old 60 a minute, you can stop.
- In MCP, `_meta.rateLimit` now comes on read tools only.

## 2026-09-19 — OAuth for the MCP server

**Added**

- MCP clients that can only use [OAuth](https://vortexdeployer.com/docs/other/glossary#oauth), like Claude.ai custom connectors, can now connect. The server offers discovery at the API host's root, client sign-up at `POST https://evm.vortexdeployer.com/evm/api/v1/oauth/register`, the authorization code flow with PKCE (`S256` only), consent in the app, refresh tokens that change on each use, and revoking. See [OAuth for connectors](https://vortexdeployer.com/docs/api/oauth).
- Each grant is tied to one of your API keys, picked on the consent page. Its `vdo_…` token works everywhere a `vd_` key does: MCP, REST and streams. It has that key's scopes and caps. Revoke the key and the grant ends.
- A `401` on `POST /mcp` now has a `WWW-Authenticate` header. It points to the server's resource info (RFC 9728).

**Changed**

- Nothing changed for `vd_` keys. Clients that use them need no update.

## 2026-09-17 — Faster Volume in the Mixed style, and trading-bot markers

**Added**

- New settings for `volume` tasks in the Mixed style (no `mode`, or `mode: "mixed"`):
  - `maxInFlight` — how many trades may be out at once, 1 to 50, one per wallet.
  - `maxSameSideStreak` — after this many trades on one side, the next one takes the other side. `0` turns it off.
  - `maxNetBuySol` — the most the run may hold, in the chain's coin. At the cap it only sells until it is back under. `0` turns it off.
- `markerPlatforms` on `volume` (Mixed) and `warmup` settings: any of `PHOTON`, `TROJAN`, `BULLX`, `AXIOM1` and `AXIOM2`, each once. Default `[]`. Each trade also sends 10 lamports to that bot's fee wallet, so the trade looks like it came from that bot. Solana only. See [Volume](https://vortexdeployer.com/docs/tasks/volume).

**Changed**

- `minDelayMs` and `maxDelayMs` in Mixed `volume` now start at 20 (it was 250). They are now the wait between sends, not between confirmations.
- `maxNetBuySol` now measures what the run still holds: the SOL paid for tokens it has not sold back. Before, it was buys minus sells. Fees and slippage made that number grow by itself, so a long run could hit the cap while it held nothing.
- `maxConsecutiveErrors` now counts bad moments, not failed trades. With `maxInFlight` above 1, the extra trades lost in the same bad moment are forgiven once. The real limit is `maxConsecutiveErrors + min(maxInFlight, wallets) − 1`.
- A sell sent through a temporary wallet carries no `markerPlatforms` tag. The temporary wallet signs it, so the tag would mark the wrong wallet. `POST /tasks/:id/preview` says how many of the task's wallets sell that way.

## 2026-09-16 — Launch tasks inside the launch call

**Added**

- `tasks[]` on `POST /launch` is now a typed list. Each task has `type` (one of the 14 launch task types at the time), `walletIds`, `config`, `label` and `autostart`. It has no `chain`: it uses the launch's. Settings are checked with the task type's own rules. A bad one gets `400 validation_failed` that names `tasks[i].config`. The wallets must be yours and on the key's list. `POST /launch/affordability` takes the same list. The `launch` MCP tool shows the full task shape. See [Launch tasks](https://vortexdeployer.com/docs/api/launch#launch-tasks).

**Changed**

- Before, `tasks[]` was passed on without checks, and every task needed `chain`. A task with a `chain` field is now refused. Leave it out.

## 2026-09-16 — Everything the app does, on the API

Each account action in the app that makes sense from code is now a route. Each route has an MCP tool. Key management stays in the app on purpose: a key that could make keys could get around its own limits. No route returns a private key.

**Added**

- Wallets: `GET` and `POST /wallets/groups`, `PATCH` and `DELETE /wallets/groups/:id`. `groupId` on `PATCH /wallets/:id`. `?scope=all` and `?groupId=` on `GET /wallets`. `GET /wallets/:id/profile`. `GET /wallets/cashback` and `POST /wallets/cashback/claim`. See [Groups](https://vortexdeployer.com/docs/api/wallets-pnl#groups).
- Projects: `POST /projects` (makes a draft), `POST /projects/cto`, `PATCH` and `DELETE /projects/:id`, `GET /projects/:id/wallets`, `POST /projects/:id/wallets/assign`, `DELETE /projects/:id/wallets/:walletId`, `POST /projects/:id/closeout` (a dry run by default) and `POST /pnl/wallet-totals`. See [Projects](https://vortexdeployer.com/docs/api/wallets-pnl#projects).
- Launch helpers: `GET /launch/readiness`, `GET /launch/mint-address`, `POST /launch/clone`, `POST /launch/affordability`, `POST /launch/supply-preview`, `POST /launch/metadata`, `GET /launch/pons/launch-terms` and `GET /launch/otcdesks/rewards`. Supply plans at `/supply-plans`, with `POST /supply-plans/:id/mount`. See [Checks before you launch](https://vortexdeployer.com/docs/api/launch#checks-before-you-launch).
- Trading: `POST /convert/assets`, `/convert/quote` and `/convert`. `POST /tokens/burn` and `/tokens/lock` (dry runs by default). `GET /tokens/creator-fees` and `POST /tokens/creator-fees/claim`. See [Convert](https://vortexdeployer.com/docs/api/trading#convert-solana).
- Tasks: `GET /events` (your activity feed, paged with `before`) and `GET /warmup/candidates`. See [Events](https://vortexdeployer.com/docs/api/tasks#events).
- Account: `GET` and `PATCH /settings/trading`. `GET` and `POST /kols`, `PATCH` and `DELETE /kols/:address`. New page: [Account settings & KOLs](https://vortexdeployer.com/docs/api/account).
- 43 new MCP tools, 84 in all at the time.

**Rules for keys**

- A key with limits (caps, a wallet list or sandbox) can only dry-run a close-out. A sandbox key can only dry-run burns, locks, converts and cashback claims.
- A key with a wallet list may only name wallets on its list, in every new route that takes wallet ids.

## 2026-09-16 — Rename and delete wallets

**Added**

- `PATCH /wallets/:id` changes a wallet's `label` (`null` clears it) or `role`. See [Change a wallet](https://vortexdeployer.com/docs/api/wallets-pnl#change-a-wallet).
- `DELETE /wallets/:id` deletes a wallet. It gets `409 conflict` while a task or a project uses the wallet. `?force=true` deletes it past the project check. See [Delete wallets](https://vortexdeployer.com/docs/api/wallets-pnl#delete-wallets).
- MCP tools `update_wallet` and `delete_wallet`.

## 2026-09-16 — See which quotes a launchpad takes

**Added**

- `GET /launchpads` lists every launchpad. For each it gives the chain and the `quoteToken` values it takes. For each quote it says if a `pairToken` is needed and which dev-buy field to use.
- `GET /launchpads/:launchpad/quotes` lists what a launch there can be quoted in right now. That includes the live list of tokenized stocks on pump.fun and StonkFun, and the pair tokens on pons. Each entry has the exact `quoteToken` and `pairToken` to send. See [Which quotes a launchpad takes](https://vortexdeployer.com/docs/api/launch#which-quotes-a-launchpad-takes).
- MCP tools `list_launchpads` and `launch_quotes`.

## 2026-09-16 — Import many wallets, straight into a project

**Added**

- `POST /wallets` takes `privateKeys`, a list of up to 100 at the time, next to `privateKey`. `projectId` puts new or imported wallets straight into one of your projects. An import is all or nothing. A wallet you already have comes back as it is. See [Make or import wallets](https://vortexdeployer.com/docs/api/wallets-pnl#make-or-import-wallets).

**Changed**

- Importing a wallet you already have no longer resets its role to `trading`. It comes back unchanged.

## 2026-09-16 — Agent discovery

**Added**

- `https://vortexdeployer.com/llms.txt` lists the docs for AI agents, and `https://vortexdeployer.com/llms-full.txt` has them all in one Markdown file. Every docs page is also Markdown at its address plus `.md`.
- `GET https://evm.vortexdeployer.com/evm/api/v1` needs no key. It answers JSON with the REST address, the OpenAPI document, the MCP server, the WebSocket and the docs.
- New page: [Build an agent on the API](https://vortexdeployer.com/docs/api/agents).
- The docs no longer need sign-in. Every `/docs` page, the API index and the OpenAPI document are open to all. Keys are still made in the app.
- `https://vortexdeployer.com/agents.txt` is a short file for agents: the addresses, how a key works, the safety rules and what may be fetched. `GET https://evm.vortexdeployer.com/evm/api/v1` names it in `agentsTxt`.

## 2026-09-16 — MCP server

**Added**

- `POST https://evm.vortexdeployer.com/evm/api/v1/mcp` serves the API as an [MCP](https://vortexdeployer.com/docs/other/glossary#mcp) server for Claude, Cursor or any MCP client. There is one tool per call, your key signs each request, and the server keeps no session. See [MCP for AI agents](https://vortexdeployer.com/docs/api/mcp).
- Every call in the OpenAPI document now has an `operationId`, like `buy`, `list_wallets` or `start_task`. Code generators name methods after it, and it is the MCP tool's name.

**Removed**

- The EVM site's unpublished `/evm/api/v1` and `/evm/ws` addresses no longer take API keys. REST there answers `404 not_found` with the right address, and the socket refuses the key. Use `https://evm.vortexdeployer.com/evm/api/v1` and `wss://evm.vortexdeployer.com/evm/ws`.

## 2026-09-16 — camelCase answers, error codes, paging and OpenAPI

**Breaking for early keys.** If you started before this date, change your code:

- **Every answer is camelCase.** `pool_address` is now `poolAddress`, `expected_out` is `expectedOut`, `created_at` is `createdAt`, `wallet_ids` is `walletIds`, and so on for every field. Wallet ids and mints used as map keys stay as they were. [Live stream](https://vortexdeployer.com/docs/api/streams) frames keep their snake_case names.
- **Errors have a `code`**, and `trace_id` is now `traceId`: `{ "code": "insufficient_scope", "error": "…", "traceId": "…" }`. Check `code`. See the [codes table](https://vortexdeployer.com/docs/api/limits-errors#codes).
- **`GET /tasks` is wrapped:** `{ "tasks": [ … ] }`, not a bare list. `GET /tasks/:id/executions` is `{ "executions": [ … ] }`.
- **Internal fields are gone** from tasks: `user_id`, `run_seq` and `execution_epoch`.
- **Projects** no longer return the stored `meta` object. Use `metadataUri` for the token's info file.
- **Check messages** have new wording, like `Too small: expected number to be >0`. Match on `code: "validation_failed"` and `details[].path`, never on the message.

**Added**

- `?limit=`, `?offset=` and `X-Total-Count` on `GET /wallets`, `GET /wallets/balances` and `GET /portfolio`. See [Paging](https://vortexdeployer.com/docs/api/limits-errors#paging).
- `X-RateLimit-Reset` next to `X-RateLimit-Limit` and `X-RateLimit-Remaining`, and `retryAfterSeconds` in every `429` body.
- `GET /openapi.json`, the OpenAPI 3.1 document for every REST call. No key needed.
- `OPTIONS` on any route answers `204` with `Allow`.

## 2026-09-16 — v1 opens

The first release: keys and scopes, buy, sell and batch, launch, wallets, portfolio and PnL, tasks and live streams. See [API overview & keys](https://vortexdeployer.com/docs/api/overview).

## See also

- [API overview & keys](https://vortexdeployer.com/docs/api/overview)
- [Limits, retries & errors](https://vortexdeployer.com/docs/api/limits-errors)
- [MCP for AI agents](https://vortexdeployer.com/docs/api/mcp)

---

# Welcome to VortexDeployer

> What VortexDeployer is, who it is for, and where to start reading.

Source: https://vortexdeployer.com/docs/overview/welcome · Markdown: https://vortexdeployer.com/docs/overview/welcome.md

VortexDeployer helps you launch new [tokens](https://vortexdeployer.com/docs/other/glossary#token) and trade them from many wallets at once. These docs explain each screen in plain words.

:::tip New here?
Start with [Start here: your first launch](https://vortexdeployer.com/docs/overview/quick-start). It takes you from sign-in to your first launch, step by step.
:::

## What you can do

- **Launch a token** on a [launchpad](https://vortexdeployer.com/docs/other/glossary#launchpad) such as pump.fun. Your own wallets can buy in the same moment.
- **Run many wallets.** Create, fund, group and empty lots of wallets in one go.
- **Trade fast.** Buy and sell from one wallet or from all of them on the token's [terminal](https://vortexdeployer.com/docs/other/glossary#terminal).
- **Automate.** Add [tasks](https://vortexdeployer.com/docs/other/glossary#task) that buy, sell or trade for you while you watch.
- **Follow X.** See new posts from X accounts as they appear, and launch a token from a post.

## Who it is for

VortexDeployer is for people who create tokens and for traders who manage many wallets. You do not need to code. You should know the basics: what a [wallet](https://vortexdeployer.com/docs/other/glossary#wallet) is, what [SOL](https://vortexdeployer.com/docs/other/glossary#sol) is, and that a trade on a blockchain cannot be undone.

It works on two [chains](https://vortexdeployer.com/docs/other/glossary#chain): Solana and Robinhood Chain. See [Chains & launchpads](https://vortexdeployer.com/docs/overview/chains-and-launchpads).

## The main parts

- [Wallets](https://vortexdeployer.com/docs/wallets/overview) — create, fund, group and empty your wallets.
- [Launch](https://vortexdeployer.com/docs/launch/create-project) — set up a new token and launch it.
- [Terminal](https://vortexdeployer.com/docs/terminal/overview) — trade a token from your wallets and follow your profit or loss.
- [Tasks](https://vortexdeployer.com/docs/tasks/overview) — let the app buy, sell or make volume on a token for you.
- [XID](https://vortexdeployer.com/docs/xid/feed) — a live feed of posts from X accounts, with launch shortcuts.
- [Account](https://vortexdeployer.com/docs/account/dashboard) — your dashboard, portfolio, settings and support.
- [API](https://vortexdeployer.com/docs/api/overview) — control your account from your own code.

:::warning Real money
Launches, trades and transfers use real SOL or ETH. They cannot be undone. The app has no test mode. Read [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run) before your first launch.
:::

## See also

- [Start here: your first launch](https://vortexdeployer.com/docs/overview/quick-start)
- [Find your way around](https://vortexdeployer.com/docs/overview/workspace)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)
- [Terminology](https://vortexdeployer.com/docs/other/glossary)

---

# Start here: your first launch

> The steps from sign-in to your first launch and back, with a link to the full guide for each step.

Source: https://vortexdeployer.com/docs/overview/quick-start · Markdown: https://vortexdeployer.com/docs/overview/quick-start.md

This page is a map of your first launch. Each step is short and links to its full guide.

:::warning From step 3 on, real money moves
The app has no test mode. Funding, launching, buying, selling and collecting all use real SOL or ETH, and none of it can be undone. Start with small amounts. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Before you start

- A Telegram account. New accounts sign up through the VortexDeployer [Telegram bot](https://vortexdeployer.com/docs/other/glossary#telegram-bot).
- Some SOL in a wallet or exchange you control. On Robinhood Chain you need ETH instead.

## The steps

1. **Sign in.** Open the app and press **Continue with Telegram**. In the bot, tap **Launch App**. See [Sign in & accounts](https://vortexdeployer.com/docs/overview/sign-in).
2. **Create wallets.** Open **Wallets** and press **New wallet**. You need one [creator wallet](https://vortexdeployer.com/docs/other/glossary#creator-wallet) and a few wallets to buy with. You can also buy ready wallets in **Marketplace**. See [Create & import](https://vortexdeployer.com/docs/wallets/create-and-import).
3. **Fund the wallets.** On **Wallets**, press **Fund**. Pick the wallets to fill and the amount. The SOL comes from one of your wallets or from a deposit you make. See [Fund wallets](https://vortexdeployer.com/docs/wallets/fund).
4. **Set up the token.** Press **Create Project** in the top bar. The wizard has four steps: **Metadata**, **Wallets**, **Tasks** and **Review & Deploy**. For a fast launch with saved defaults, press **Quick** in the bottom bar instead. See [Create a project](https://vortexdeployer.com/docs/launch/create-project) and [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy).
5. **Launch.** On **Review & Deploy**, fix anything listed under "Before you can launch, add:". Check the totals line. Then press **Create**. The launch starts at once. There is no extra confirm. See [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings).
6. **Watch your token.** After the launch, the app opens the token's [terminal](https://vortexdeployer.com/docs/other/glossary#terminal). It shows your **Position**, a **Trade** panel and a **Tasks** panel. See [After launch](https://vortexdeployer.com/docs/launch/after-launch) and [The terminal](https://vortexdeployer.com/docs/terminal/overview).
7. **Add a task.** In the **Tasks** panel, press **New task**. Pick a [task](https://vortexdeployer.com/docs/other/glossary#task) and press **Create task**. If its card has a **Preview**, open it to check the plan. Then press **Start**. See [How tasks run](https://vortexdeployer.com/docs/tasks/overview).
8. **Take profit.** Sell part of your tokens in the **Trade** panel. Or press **Sell all** to sell from every wallet at once. See [Trade panel](https://vortexdeployer.com/docs/terminal/trade-panel) and [Sell all](https://vortexdeployer.com/docs/terminal/sell-all).
9. **Collect your funds.** When you are done, open **Wallets** and press **Collect**. It sends the SOL back to a wallet you choose. To sell, close and collect in one go, use [Close out](https://vortexdeployer.com/docs/launch/close-out). See [Collect funds](https://vortexdeployer.com/docs/wallets/collect).

![The Create Project wizard on Metadata, with its four steps on the left](https://vortexdeployer.com/docs/overview/quick-start.png)

:::tip Want to test first?
There is no practice mode. Do a small launch with a tiny [dev buy](https://vortexdeployer.com/docs/other/glossary#dev-buy), or one small buy on an existing token. Check the costs in [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees).
:::

## See also

- [Find your way around](https://vortexdeployer.com/docs/overview/workspace)
- [Best practices](https://vortexdeployer.com/docs/other/best-practices)
- [Troubleshooting](https://vortexdeployer.com/docs/other/troubleshooting)

---

# Find your way around

> Where everything is in the app — the top bar, your account menu, the project list, the bottom bar and settings.

Source: https://vortexdeployer.com/docs/overview/workspace · Markdown: https://vortexdeployer.com/docs/overview/workspace.md

This page shows where things are in the app. Use it when you cannot find a screen or a button.

![The app on a wide screen: the top bar, the project column on the left and the bottom bar](https://vortexdeployer.com/docs/overview/workspace.png)

## The top bar

The top bar is always on screen. From left to right:

- **Dashboard** — your overview: balance, total [P&L](https://vortexdeployer.com/docs/other/glossary#p-l) and how many tokens you launched.
- **Projects** — every token you set up, launched or not.
- **Wallets** — your wallets, with the **Fund**, **Collect** and other tools.
- **XID** — a live feed of posts from X accounts.
- **Marketplace** — buy ready-made wallets.

On the right side you find:

- **V1** — opens the older version of VortexDeployer.
- **CTO** — take over an existing token. See [CTO an existing token](https://vortexdeployer.com/docs/launch/cto). It shows on wide screens only.
- **Create Project** — starts the launch wizard.
- Your account menu.

## Your account menu

Click your picture or initial at the top right. The menu holds **Portfolio**, **Swap**, **Copy deploy** and **Support**. Below them are **Referrals**, **Account settings**, **Docs** and **API**. **Sign out** is at the bottom. [Copy deploy](https://vortexdeployer.com/docs/launch/copy-deploy) launches a copy of each new token another creator makes.

## Your projects on the left

On wide screens, a thin column on the left lists your 20 newest projects.

- A project with a dashed ring is a draft. Click it to go back to the wizard.
- A launched project opens its token's [terminal](https://vortexdeployer.com/docs/other/glossary#terminal).
- **Browse projects** (the search icon) finds any project by name, symbol or address.
- **+** starts a new project.

## The bottom bar

The bottom bar has three parts.

- **Left:** the connection state, then shortcuts. **Copy deploy**, **XID** (opens the feed in a side panel), **Tracker** (the KOL tracker), **Quick** ([Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy)), **Help**, **Bug** and **Suggest**.
- **Middle:** a chip for each work window you made smaller. Click a chip to open it again.
- **Right:** the bell for notifications, SOL and ETH prices, the pump.fun and pons graduation market caps, **Docs** and **API**.

![The bottom bar: the connection state and shortcuts on the left, the bell, prices, Docs and API on the right](https://vortexdeployer.com/docs/overview/workspace-bottom-bar.png)

The connection state reads **Connected** when all is well. **Connecting** or **Checking** means the app is reaching the server. **Offline** or **API down** means live updates have stopped. Wait, or reload the page.

:::tip Bug reports
**Bug** sends a report with the page you are on and its technical details attached. Use it when something looks wrong.
:::

## Where things moved

Some screens from older versions now live somewhere else.

- **Tasks** have no page of their own. Open a token's terminal and use its **Tasks** panel. See [How tasks run](https://vortexdeployer.com/docs/tasks/overview).
- **Long jobs** such as funding or collecting open in a window that shows their progress. See [Operation progress](https://vortexdeployer.com/docs/account/operations).
- **Notifications** open from the bell in the bottom bar. Their settings are in **Account settings** → **Notifications**. See [Notifications](https://vortexdeployer.com/docs/account/notifications).

## On a phone

Press **Open menu** at the top. It holds the top-bar links, **Create Project** and **CTO**. It also has **Copy monitor**, **Quick deploy**, **KOL tracker**, **Report a bug** and **Suggest a feature**.

![The phone menu, opened with Open menu](https://vortexdeployer.com/docs/overview/workspace-phone.png)

## Settings

Open **Account settings** from your account menu. The list on the left has three groups.

- **Account** — **Profile** (name and sign-in) and **Notifications**.
- **Trade & launch** — **Trading**, **Quick deploy** and **Supply plans**.
- **App** — **Workspace**. Here **Display density** sets the space between controls: **Compact** or **Comfortable**.

See [Settings](https://vortexdeployer.com/docs/account/settings) for every option.

## Search the docs

In the docs, use **Search docs** at the top of the side menu. You can also press `/` or Ctrl+K (⌘K on a Mac).

## See also

- [Start here: your first launch](https://vortexdeployer.com/docs/overview/quick-start)
- [Sign in & accounts](https://vortexdeployer.com/docs/overview/sign-in)
- [Dashboard](https://vortexdeployer.com/docs/account/dashboard)

---

# Sign in & accounts

> How to sign up and sign in with Telegram, add a browser password, and keep your account safe.

Source: https://vortexdeployer.com/docs/overview/sign-in · Markdown: https://vortexdeployer.com/docs/overview/sign-in.md

Your VortexDeployer account starts in Telegram. You sign in through the VortexDeployer [Telegram bot](https://vortexdeployer.com/docs/other/glossary#telegram-bot). Later you can add a username and password for any browser.

## Sign up or sign in with Telegram

![The Welcome back card with Continue with Telegram](https://vortexdeployer.com/docs/overview/sign-in.png)

1. Open the app. On the **Welcome back** card, press **Continue with Telegram**.
2. Telegram opens the bot (@DeployOnVortexBot). Start it.
3. The bot replies with a **Launch App** button. Tap it.
4. The app opens and you are signed in.

The **Launch App** link works once and runs out after 10 minutes. If it fails, press **Continue with Telegram** again to get a new one.

New accounts are made this way. There is no sign-up form in the browser.

:::tip Inside Telegram
If you open the app inside Telegram as a mini app, it signs you in by itself.
:::

## Add a username and password

Browser sign-in is off for new accounts. It unlocks when you reach the Silver [fee tier](https://vortexdeployer.com/docs/other/glossary#fee-tier). See [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees). Until then, **Profile** says "Password sign-in is off for this account; the operator enables it." If you need it sooner, ask [Support](https://vortexdeployer.com/docs/account/support).

Once it is unlocked:

1. Open your account menu and pick **Account settings**.
2. Pick **Profile**. Find the group **Set up browser sign-in**.
3. Enter a **Username**. Use 3–24 characters: lowercase letters, digits or `_`.
4. Enter a **New password** of 8–200 characters. Type it again in **Confirm password**.
5. Press **Enable browser sign-in**.

Now you can sign in from any browser. On the **Welcome back** card, fill in **Username** and **Password**, then press **Sign in**.

## Change your username or password

1. Open **Account settings** → **Profile**. The group is now called **Username and password**.
2. Enter your **Current password**.
3. Enter the new details.
4. Press **Save sign-in details**.

:::warning A new password signs out your other devices and stops your API keys
Saving new sign-in details ends every other session. It also cancels all your [API keys](https://vortexdeployer.com/docs/other/glossary#api-key). Any bot or script that uses them stops working. Make new keys on the **API** page afterwards.
:::

## Sign out

**Sign out** is at the bottom of your account menu. It ends your session on every device, not only this one. Your API keys keep working.

## Your password guards your keys

When you export a wallet's [private key](https://vortexdeployer.com/docs/other/glossary#private-key), the app asks for your **Account password** if you have set one. See [Export a private key](https://vortexdeployer.com/docs/wallets/key-export).

## Troubleshooting

- **"Wrong username or password."** — Check both. Usernames are lowercase. If you forgot the password, sign in with Telegram and ask [Support](https://vortexdeployer.com/docs/account/support). You need the current password to set a new one.
- **"Could not sign in. Check your connection and try again."** — The app could not reach the server. Check your internet and try again.
- **Service unreachable** — The app cannot reach its server right now. Press **Retry**, or **Sign out instead**.
- **"Your session has ended. Sign in again to continue."** — You signed out on another device, or your password changed. Sign in again.
- **"Username must be lowercase."** — Use only small letters, digits and `_`. Spaces and dashes are not allowed.
- **"Passwords do not match."** — Type the same password in **New password** and **Confirm password**.
- **"Enter your current password to change your credentials."** — Your account already has a password. Type it in **Current password**.

## See also

- [Find your way around](https://vortexdeployer.com/docs/overview/workspace)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)
- [Export a private key](https://vortexdeployer.com/docs/wallets/key-export)
- [API overview & keys](https://vortexdeployer.com/docs/api/overview)

---

# Chains & launchpads

> Which chains and launchpads VortexDeployer supports, what each one is priced in, and what differs between chains.

Source: https://vortexdeployer.com/docs/overview/chains-and-launchpads · Markdown: https://vortexdeployer.com/docs/overview/chains-and-launchpads.md

VortexDeployer works on two [chains](https://vortexdeployer.com/docs/other/glossary#chain): Solana and Robinhood Chain. Each launch goes to one [launchpad](https://vortexdeployer.com/docs/other/glossary#launchpad). You pick it in the first step of the launch wizard.

## Chains

- **Solana** — you pay in [SOL](https://vortexdeployer.com/docs/other/glossary#sol). Most launchpads and all tasks are here. Transactions open on solscan.
- **Robinhood** (Robinhood Chain) — you pay in [ETH](https://vortexdeployer.com/docs/other/glossary#eth). The pons launchpad is here. Transactions open on rh-scan.

Every wallet belongs to one chain. When you create or import a wallet, you pick its chain. Solana is the default.

## Launchpads

The **Quote** is what the token's [bonding curve](https://vortexdeployer.com/docs/other/glossary#bonding-curve) is priced in. If a launchpad offers only one quote, the picker tells you.

| Launchpad | Chain | Quote choices | After graduation |
|---|---|---|---|
| **Pump.fun** | Solana | SOL, USDC, **Custom pairs** | PumpSwap |
| **LaunchLab** (Raydium) | Solana | SOL, USD1 | Raydium |
| **Bonk** (letsbonk.fun) | Solana | SOL, USD1 | Raydium |
| **Bonkers** | Solana | SOL, USD1 | Raydium |
| **StonkFun** | Solana | a tokenized stock | Raydium |
| **Bags** | Solana | SOL | Meteora |
| **pons** | Robinhood | ETH, USDG, a tokenized stock | Uniswap V4 |

[Graduation](https://vortexdeployer.com/docs/other/glossary#graduation) is when a token's curve fills up and trading moves to a normal pool. The bottom bar shows the market cap where pump.fun and pons tokens graduate.

## Launchpad options

![The launchpad, quote, mode, fees and OTC Desks choices on the first wizard step](https://vortexdeployer.com/docs/overview/chains-and-launchpads.png)

**Pump.fun**

- **Custom pairs** — price the curve in a [tokenized stock](https://vortexdeployer.com/docs/other/glossary#tokenized-stock) from pump.fun's list, or in another pump.fun coin. See [Pair tokens](https://vortexdeployer.com/docs/launch/pair-tokens).
- **Mode** — **Classic** or **Mayhem**. Mayhem needs a SOL or USDC quote.
- **Fees** — **Creator Fees** or **Holder Rewards**. With Holder Rewards, pump.fun pays the [creator fees](https://vortexdeployer.com/docs/other/glossary#creator-fees) to eligible holders. A holder must hold more than $20 worth. This choice is permanent.
- **Custom-pair fee (%)** — for custom pairs, from 0.01% to 3%. It is final at launch.

**StonkFun**

- **Mode** — **Standard**, **Reward**, or **Community** where the stock offers it.
- **Tax** — 1% or 3%, for Reward and Community. It is taken on every transfer of your token. Reward pays it out to your token's holders. Community splits it between the stock's holders and your token's holders.

**pons**

- **Creator fees** — who gets the creator share of each trade: **Creator wallet**, **Holders** or **Custom address**. You also set the creator **Tax**.
- **Buyback** — the platform share buys your token back off the curve.
- With a pair token, each wallet's ETH is swapped into that token right before the launch. The swap pays a 1% router fee.

See [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings) for every option.

## What differs between chains

- **Tasks** — **Bundle**, **Hand Switcher**, **Fake Volume** and **Migrate & Buy** run on Solana only.
- **Wallet tools** — **Convert** and **Claim cashback** work on Solana only.
- **Platform fee** — on Solana it is paid inside your trade. On Robinhood Chain it is a separate ETH transfer, and fees under $1 are added up and paid later. See [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees).
- **One transaction at a time** — a Robinhood Chain wallet sends one transaction at a time. A second one sent before the first lands is refused. Try again a moment later.

:::info The dev buy pays in the quote
For SOL quotes, pump.fun custom pairs and StonkFun, the [dev buy](https://vortexdeployer.com/docs/other/glossary#dev-buy) spends SOL. For USDC or USD1 quotes, the creator wallet must hold that coin. On pons, the dev buy spends ETH. With a pair token, that ETH is swapped first.
:::

## See also

- [Create a project](https://vortexdeployer.com/docs/launch/create-project)
- [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings)
- [Pair tokens](https://vortexdeployer.com/docs/launch/pair-tokens)
- [OTC Desks pairing](https://vortexdeployer.com/docs/launch/otc-desks)

---

# Real funds & confirms

> What spends real money in VortexDeployer, which actions ask you first, and how to check a plan before you spend.

Source: https://vortexdeployer.com/docs/overview/dry-run · Markdown: https://vortexdeployer.com/docs/overview/dry-run.md

Everything in VortexDeployer happens on a real blockchain with real SOL or ETH. This page lists what spends money, what asks you first, and how to check a plan before you spend.

:::danger There is no test mode in the app
The app has no Dry run or Simulate switch. Every launch, trade, task and transfer is real. A confirmed [transaction](https://vortexdeployer.com/docs/other/glossary#transaction) cannot be undone, and nobody can reverse it for you.
:::

## What spends real money

- **Launching** — the [dev buy](https://vortexdeployer.com/docs/other/glossary#dev-buy), the buys from your launch wallets, and about 0.03 SOL of [network fees](https://vortexdeployer.com/docs/other/glossary#network-fee) and [rent](https://vortexdeployer.com/docs/other/glossary#rent) on top.
- **Buying and selling** — the amount you trade, network fees and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee).
- **Tasks** — every buy and sell a task makes, for as long as it runs.
- **Moving funds** — **Fund**, **Collect**, **Transfer**, **Convert** and the mixer.
- **Wallet warm-up** — real trades on live pump.fun coins.
- **Copy deploy** — each copy is a real launch. See [Copy deploy](https://vortexdeployer.com/docs/launch/copy-deploy).
- **Marketplace** — buying wallets.

## Actions that ask first

These actions show a confirm box or a review step. Read it before you go on.

| Action | What you see first |
|---|---|
| **Transfer** from one wallet | "Really send … ? This is irreversible." |
| **Collect** | The **Confirm collection** window: "This moves real funds and cannot be undone." Press **Collect now** to go on. |
| **Convert** | **Review conversion** shows the plan. Then the button reads, for example, **Convert 3 wallets**. |
| **Warm up** | "Warm up … wallets with real trades? Each buy spends …" |
| **Dev warmup** | "Launch … real tokens from …?" |
| **Claim cashback** | "Claim … SOL of cashback on … wallets?" |
| Deleting wallets | "Delete … wallets? Export any key you still need first." |
| [Burning tokens](https://vortexdeployer.com/docs/terminal/burn-and-lock) | "… Burning is permanent." |
| Locking tokens | "… The lock cannot be cancelled or moved early." |
| **Copy deploy** | "Each copy is a real launch that spends the dev buy, rent and network fees …" |

## Actions that do not ask

- **Create** on **Review & Deploy** launches at once. The wizard lists anything missing under "Before you can launch, add:". Once that list is empty, one press sends the launch.
- **Deploy** in [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy) launches at once.
- Buys and sells in the **Trade** panel, and **Sell all**, run on one press. You can turn on a confirm for some of them (below).
- **Create & start** starts a task at once.
- **Claim all** in the creator fees window sends the claim at once. See [Claim creator fees](https://vortexdeployer.com/docs/launch/after-launch#claim-creator-fees).

:::warning Check the totals before Create
The wizard shows a line like "Dev buy … · Task buys … · fees and rent extra". That is what the launch will spend.
:::

## Turn on trade confirms

1. Open **Account settings** → **Trading**.
2. Under **Confirmations**, turn on **Confirm dev trades**, **Confirm Sell all**, or both.
3. Press **Save trading settings**.

![The Confirmations group in Account settings, Trading](https://vortexdeployer.com/docs/overview/dry-run.png)

Both are off by default.

- **Confirm Sell all** — asks before every **Sell all**: "Really sell all from … wallets?"
- **Confirm dev trades** — asks before a quick buy or sell that includes a wallet with the **Dev** role.

## Check a plan before you spend

- **Task Preview** — Buy, Snipe, Migrate & Buy, Token Sender and Wallet warm-up can show what they will do. Create the task without **Start immediately**, then open **Preview** on its card. Press **Recompute** after you change a setting. Other tasks have no preview.
- **Review & Deploy** — check the wallets, amounts and totals.
- **Start small** — try one small buy, or a launch with a tiny dev buy, first.
- **For developers** — an API key with **Sandbox** turned on can only make dry-run calls. Nothing is sent on chain. See [API overview & keys](https://vortexdeployer.com/docs/api/overview).

:::info Old saved setups
A task setup saved before simulation was removed shows "This saved setup uses simulation, which is no longer available." Press **Use real trading** to use it. That setup will then spend real funds.
:::

## See also

- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)
- [Best practices](https://vortexdeployer.com/docs/other/best-practices)
- [Settings](https://vortexdeployer.com/docs/account/settings)
- [Collect funds](https://vortexdeployer.com/docs/wallets/collect)

---

# Platform fees & tiers

> What VortexDeployer charges on trades and launches, how fee tiers lower your rate, and what has no fee.

Source: https://vortexdeployer.com/docs/overview/fees · Markdown: https://vortexdeployer.com/docs/overview/fees.md

VortexDeployer takes a [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee) on each buy and sell your wallets make. The rate depends on your [fee tier](https://vortexdeployer.com/docs/other/glossary#fee-tier). The more fees you have paid in total, the lower your rate.

## Fee tiers

| Tier | Total fees paid | Fee rate |
|---|---|---|
| New | $0 | 2% |
| Bronze | $5,000 | 1.6% |
| Silver | $10,000 | 1.3% |
| Gold | $20,000 | 1.05% |
| Diamond | $40,000 | 0.8% |

- Your tier comes from the total platform fees you have paid, in US dollars, on both chains together.
- There is no subscription. You move up by yourself when your total crosses a step.
- Silver unlocks browser sign-in with a password. See [Sign in & accounts](https://vortexdeployer.com/docs/overview/sign-in).
- **Dev warmup** on the **Wallets** page needs the highest tier.
- Support can give an account a different rate or tier.

:::info Your tier is not shown in the app
The app does not show your tier or your rate. Ask [Support](https://vortexdeployer.com/docs/account/support) if you want to know them.
:::

## What the fee is charged on

- **Buys** — the amount you spend. The fee is paid on top. A 1 SOL buy at 2% costs 1 SOL plus 0.02 SOL.
- **Sells** — the lowest amount your sale may return under your [slippage](https://vortexdeployer.com/docs/other/glossary#slippage) setting. For a market sell, such as **Sell all**, it is the amount the sale is expected to return.
- **The dev buy at launch** — the same rate as a buy. The launch itself has no room for the fee, so it is collected from your wallets on that chain right after the launch.

The fee is charged whether the trade makes or loses money.

## How each chain pays

**Solana**

- The fee is part of the same transaction as your trade. If the trade fails, no platform fee is taken. You still pay the [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee).
- Trades priced in USDC, USD1 or a tokenized stock also pay the fee in SOL. It is worked out from the trade's dollar value.
- The very first fee a wallet pays is at least 0.00089088 SOL. That is the smallest balance a new Solana account may hold.

**Robinhood Chain**

- The fee is a separate ETH transfer, sent after your trade lands.
- A fee under $1 is not sent at once. It is added to the next fee. Fees still owed are collected from your wallets on that chain about every 30 minutes.
- A trade with no ETH in or out, for example one paid only in USDG, has no platform fee.

## What has no platform fee

- **Moving funds** — **Fund**, **Collect**, **Transfer** and the mixer. You still pay network fees. The mixer service charges its own fee.
- **Pro trader boost buys** — that task charges its own price in SOL instead, once for each run. See [Pro trader boost](https://vortexdeployer.com/docs/tasks/pro-trader-boost).
- **Claiming creator fees** — the claim pays only the network fee, and sometimes rent. See [Claim creator fees](https://vortexdeployer.com/docs/launch/after-launch#claim-creator-fees).
- **Network fees, rent and launchpad fees** — these go to the chain and the launchpad, not to VortexDeployer. [Rent](https://vortexdeployer.com/docs/other/glossary#rent) is a small deposit a new account must hold.

## Where you see the fee

- **MAX** and percent buys keep back enough for the platform fee and network costs.
- Your [P&L](https://vortexdeployer.com/docs/other/glossary#p-l) counts platform fees as a cost.
- The sell review notes when its amounts are "Before platform fees."

:::warning Fees add up on busy tasks
Volume tasks buy and sell many times. Every one of those trades pays the fee. Count it in your budget before you start a long task.
:::

## See also

- [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run)
- [Pro trader boost](https://vortexdeployer.com/docs/tasks/pro-trader-boost)
- [Support](https://vortexdeployer.com/docs/account/support)

---

# Wallets overview

> Find your way around the Wallets page, and learn what each button in the Actions panel does.

Source: https://vortexdeployer.com/docs/wallets/overview · Markdown: https://vortexdeployer.com/docs/wallets/overview.md

The **Wallets** page holds every [wallet](https://vortexdeployer.com/docs/other/glossary#wallet) the app manages for you. Here you make wallets, sort them, move money in and out, and save their keys.

:::warning Everything here is real
Each wallet holds real SOL or ETH on a live [chain](https://vortexdeployer.com/docs/other/glossary#chain). Every action on this page moves real funds, and there is no test mode. Read each confirm before you press it. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Global wallets and project wallets

The switch at the top picks what you see:

- **Global wallets** — your [wallet pool](https://vortexdeployer.com/docs/other/glossary#wallet-pool): every wallet you made, imported or bought. You can sort them into [folders](https://vortexdeployer.com/docs/wallets/groups).
- **Project wallets** — the wallets of one [project](https://vortexdeployer.com/docs/other/glossary#project). Pick it in the left column, or find it with **Search projects**.

In **Project wallets**, the **Origin** column says where each wallet came from:

- `project` — made inside this project. Other projects can use it too.
- `assigned` — a pool wallet you linked to this project. It stays in your pool.

**Assign from pool** links pool wallets to the open project. **Remove from project** takes them out of the project. Nothing is deleted: an `assigned` wallet stays in your pool, and a `project` wallet moves to your pool. Deleting a project moves its wallets to your pool too.

## The layout

On a wide screen the page has three columns: **Folders** (or **Projects**) on the left, the wallet table in the middle, and the **Actions** panel on the right.

![The Wallets page: Folders on the left, the wallet table in the middle and the Actions panel on the right](https://vortexdeployer.com/docs/wallets/overview.png)

Above the table you can search by address or label, filter by chain (**All chains**) and role (**All roles**), and sort. **Hide empty** hides wallets with no balance.

On a phone the page is one column. The folder picker and **Folders** come first, then the **Actions** panel folded shut, then search and **Filters**. Each wallet is a card with its label, address, role and balance.

![The Wallets page on a phone](https://vortexdeployer.com/docs/wallets/overview-phone.png)

## The wallet table

| Column | What it shows |
|---|---|
| **Wallet** | The label and address. Click the label to rename it. |
| **Role** | What the wallet is for. See Roles below. |
| **Folder** | Its folder. Pick another one to move it. |
| **Balance** | The live balance. It shows `connecting…` until the first check. |
| **⋯** | **Activity**, **Copy address**, **Export key**, **Delete wallet** |

**Activity** shows the wallet's age, its trades, the tokens it traded, the SOL it spent and received, and its realized [PnL](https://vortexdeployer.com/docs/other/glossary#pnl).

## Roles

A [wallet role](https://vortexdeployer.com/docs/other/glossary#wallet-role) is a short tag that says what a wallet is for: **Bundle**, **Sniper**, **Dev**, **Trading**, **Fee** or **Holder**. New wallets start as **Trading**.

- Click the role in the table (**Change role**) to pick another. **Custom role…** adds your own: lowercase letters, digits and `_`, up to 32 characters.
- **Dev** marks a [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet), the wallet that creates a token. Dev wallets are listed first.
- A **Trading** wallet that joins a bundle task becomes **Bundle**. One that joins a snipe task becomes **Sniper**. A role you set yourself never changes.

## Select wallets

Tick the box at the start of a row. The bar above the table then offers **Move to folder**, **Unassign**, **Export keys**, **Delete** and, in a project, **Remove from project**. **Copy** copies the ticked addresses, or every address in view. On a narrower screen these buttons sit in the Actions panel under **Selection**.

## The Actions panel

Each action works on the wallets you ticked. With nothing ticked, it works on every wallet in view. **Funds (N)** shows how many that is.

| Button | What it does |
|---|---|
| **Fund** | Sends SOL or ETH into many wallets. See [Fund wallets](https://vortexdeployer.com/docs/wallets/fund). |
| **Collect** | Pulls SOL or ETH from many wallets to one address. See [Collect funds](https://vortexdeployer.com/docs/wallets/collect). |
| **Transfer** | Sends from one wallet to any address. See below. |
| **Convert** | Swaps one token for another in each wallet. See below. |
| **Claim cashback** | See [Claim cashback](https://vortexdeployer.com/docs/wallets/cashback). |
| **New wallet** | See [Create & import](https://vortexdeployer.com/docs/wallets/create-and-import). |
| **Warm up**, **Dev warmup** | Give wallets a history. See [Wallet warm-up](https://vortexdeployer.com/docs/wallets/warm-up). |

Convert and Claim cashback work on Solana wallets only. Fund, Collect, Transfer and the warm-ups each start a [task](https://vortexdeployer.com/docs/other/glossary#task). Closing the window does not stop it.

### Transfer

1. Press **Transfer**. **Send SOL to address** opens (ETH on Robinhood).
2. Pick the **Source wallet (pays + sends)** and paste the **Destination address**.
3. Enter the **Amount to send**. Press **Send SOL now**, then confirm.

The source wallet also pays a small [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee) and keeps a little [rent](https://vortexdeployer.com/docs/other/glossary#rent). To empty a wallet fully, use **Collect**.

:::danger A send cannot be undone
Funds sent to a wrong address are gone. Check the address before you confirm.
:::

### Convert

**Convert** swaps a token inside each wallet, for example SOL to USDC. You review the trades first, and no tokens move until you press **Convert N wallets**. See [Convert tokens](https://vortexdeployer.com/docs/wallets/convert).

## Delete a wallet

**Delete wallet** in the row menu, or **Delete** on a selection, asks first.

- A wallet used by a running or paused task cannot be deleted.
- A pool wallet that is still in a project asks again. If you go ahead, it leaves those projects too.
- Deleting removes the wallet from your lists. It does not move its funds.

:::warning Take the funds out first
Collect the wallet's funds or [export its key](https://vortexdeployer.com/docs/wallets/key-export) before you delete it. If you import the same key later, the wallet comes back.
:::

## See also

- [Create & import](https://vortexdeployer.com/docs/wallets/create-and-import)
- [Fund wallets](https://vortexdeployer.com/docs/wallets/fund)
- [Folders](https://vortexdeployer.com/docs/wallets/groups)
- [Wallets step](https://vortexdeployer.com/docs/launch/wallets-step)

---

# Create & import

> Make new wallets, or bring in wallets you already own, with a role, a label and a folder.

Source: https://vortexdeployer.com/docs/wallets/create-and-import · Markdown: https://vortexdeployer.com/docs/wallets/create-and-import.md

**New wallet** makes fresh wallets for you, or imports wallets you already own. Make wallets here before you fund them or use them in a launch.

## Where new wallets go

- In **Global wallets**, new wallets join your [wallet pool](https://vortexdeployer.com/docs/other/glossary#wallet-pool). If a folder is open, they go into that folder.
- In **Project wallets**, they are made inside the open [project](https://vortexdeployer.com/docs/other/glossary#project). You can still use them in other projects.

## Make new wallets

1. Open **Wallets** and press **New wallet** in the Actions panel.
2. Pick **Generate**.
3. Pick the **Chain**: Solana or Robinhood. This choice only shows when more than one chain is on. A wallet lives on one chain only.
4. Enter **How many**. There is no upper limit.
5. Set the **Role**, or press one of the role buttons. The default is `trading`. See [wallet role](https://vortexdeployer.com/docs/other/glossary#wallet-role).
6. Fill in **Label (optional)**. With several wallets, each one gets a number: "dev wallet 1", "dev wallet 2", and so on.
7. Press **Generate** (it shows the count, for example **Generate 20**).

![The New wallet window](https://vortexdeployer.com/docs/wallets/create-and-import.png)

The app keeps each [private key](https://vortexdeployer.com/docs/other/glossary#private-key) encrypted. It never shows a key unless you [export it](https://vortexdeployer.com/docs/wallets/key-export).

:::info New wallets are empty
A new wallet holds no SOL. Making one costs nothing. To use it, send it funds with [Fund wallets](https://vortexdeployer.com/docs/wallets/fund).
:::

## Import wallets you own

1. Press **New wallet** and pick **Import**.
2. Pick the **Chain**.
3. Paste your keys into **Secret keys, one per line**:
  - Solana: a [base58](https://vortexdeployer.com/docs/other/glossary#base58) key (the kind Phantom exports), a byte array like `[1,2,…]`, or base64.
  - Robinhood: a key that starts with `0x` (the kind MetaMask or Rabby exports).
4. Set the **Role** and the **Label (optional)**. Put `{n}` in the label to choose where the number goes.
5. Press **Import** (with the count, for example **Import 5**).

If a line is not a valid key, the app names it, for example `line 2: …`. All the other keys still import.

If you import a key you deleted before, that wallet comes back.

### Import from a file

Press **Import from file** above the key box. It takes a `.json` or `.txt` file:

- **A wallet file** that you saved with **Download file** when you [exported keys](https://vortexdeployer.com/docs/wallets/key-export). Each wallet keeps its chain, role, label and folder. Missing folders are made for you. In a project, folders are ignored.
- **A plain text file** with one key per line. The keys fill the box, then you pick the chain, role and label.

The window sums up a wallet file before anything is saved. **Remove file** clears it. The button then reads **Import N from file**. If one row in a wallet file is bad, nothing from that file is saved.

A wallet you already have keeps its key. It takes the role, label and folder from the file.

:::warning Imported keys may not be private
A key you import is only as safe as the place it came from. If someone else ever saw it, they can still empty the wallet. When in doubt, generate a fresh wallet here.
:::

## Options

- **Chain** — Solana or Robinhood. Shown only when more than one chain is on.
- **How many** — at least 1, no upper limit.
- **Role** — default `trading`. Lowercase letters, digits and `_`, up to 32 characters.
- **Label (optional)** — up to 120 characters. Several wallets are numbered; `{n}` sets where the number goes.

## See also

- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)
- [Folders](https://vortexdeployer.com/docs/wallets/groups)
- [Fund wallets](https://vortexdeployer.com/docs/wallets/fund)
- [Wallet Marketplace](https://vortexdeployer.com/docs/wallets/marketplace)

---

# Wallet Marketplace

> Buy ready-made wallets that already have funds, age or trading history, and see where they land.

Source: https://vortexdeployer.com/docs/wallets/marketplace · Markdown: https://vortexdeployer.com/docs/wallets/marketplace.md

The **Wallet Marketplace** sells ready wallets. Some hold funds, some are weeks old with real trades, and some are dev wallets that have already launched tokens. Buy them when you need wallets that look lived-in today.

:::warning You pay with real SOL or ETH
A purchase is paid on-chain and cannot be undone. Read the totals before you press **Continue to payment**. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Pick a wallet type

Open **Wallet Marketplace**. Under **Wallet type**, pick one:

- **Funded Solana** — holds a USDC balance, which you keep.
- **Aged Solana** or **Aged Robinhood** — has a trading history. See [aged wallet](https://vortexdeployer.com/docs/other/glossary#aged-wallet). Pick **All traders**, **Pro traders** or **Regular**.
- **Solana dev** or **Robinhood dev** — a [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet) prepared for launches.

![The Wallet Marketplace: wallet types, quick select, filters and the list](https://vortexdeployer.com/docs/wallets/marketplace.png)

## Filter the list

- **Funding source** — the exchange that first sent funds to the wallet, such as Binance. **Not recorded** means it is unknown. See [funding source](https://vortexdeployer.com/docs/other/glossary#funding-source).
- **Wallet age** — **Any age**, or 2, 4, 7, 14 or 30+ days.
- **Funding order** — **Oldest first** or **Newest first**.
- **Trader profile** — aged wallets only: **US**, **Europe** or **Asia**.

**Reset filters** clears them all. Each row shows the funding date, the wallet's age, its trades or launches, the balance inside and the price. The address stays hidden until you buy.

## Choose wallets

Tick wallets one by one, or let **Quick select** pick them:

1. Set **Wallet count**. The default is 10.
2. Set **Funding gap**, from **30 minutes** to **6 hours**.
3. Press **Select wallets**. It says how many it found, for example "Selected 18 of 25 wallets."

The funding gap keeps your wallets from looking related: any two wallets you pick were funded at least that far apart. A wallet that breaks the gap cannot be ticked.

Some wallets for sale were first funded from the same wallet. You can buy them together in one order, if they meet the gap. Once you have bought one of them, the others are greyed out in later orders. They show the note "Shares a funding source with one of your previous purchases".

## Check the price

The bar under the list sums up your picks:

- **Wallet cost** — the price minus the balance already inside.
- **Balance you keep** — the SOL, ETH or USDC already in the wallets. It becomes yours.
- **Total to pay** — everything you send. Nothing is added on top.

![Two wallets picked, with the cost line before you pay](https://vortexdeployer.com/docs/wallets/marketplace-selected.png)

When USDC is included, the figures say "(estimated)", because USDC is counted at today's rate.

## Pay

1. Press **Continue to payment**. Your wallets are held for you for 30 minutes, and **Checkout** opens with a countdown.
2. Send the **Exact amount to send** to the **Payment address**, on the chain shown. Use the copy buttons or the QR code.
3. Wait. Checkout looks for your payment by itself. **Check payment** looks right away.
4. When the payment arrives, you see **Wallets delivered** and the addresses. Press **Open Wallets**.

You can close checkout while you wait. **Resume payment** brings it back. You can have one unpaid order at a time.

:::warning Send the full amount, in time
Pay the exact amount, in one go, before the countdown ends. An exchange's withdrawal fee can make your payment arrive short. If time runs out, the wallets go back on sale. Do not send to that payment address any more.
:::

## Where your wallets land

Bought wallets join your [wallet pool](https://vortexdeployer.com/docs/other/glossary#wallet-pool) under **Global wallets**. Each order gets its own new folder: **Marketplace #** plus the first 8 characters of the **Order ID**, for example **Marketplace #1a2b3c4d**. If you already have a folder with that name, the full order ID is used.

Dev wallets arrive with the **Dev** role, all others as **Trading**. A new wallet's balance may show `connecting…` until it is checked.

## Purchase history

**Purchase history** lists every order with its **Date**, **Type**, **Amount**, **Status** and **Order ID**. Click an order to open it.

- **Awaiting payment** — the order waits for your payment.
- **Delivered** — the wallets are yours.
- **Expired** — time ran out. If you paid late, press **Check late payment**.
- **Needs review** — a payment arrived but could not complete the order, for example too late or too little. Press **Open Support** and give the order ID.

## Troubleshooting

- **"The quote changed."** — prices moved since you picked. Refresh the page and pick again.
- **"One or more wallets are no longer available."** — someone bought them first. Refresh and pick again.
- **"Finish your pending marketplace order first"** — pay or wait out your open order.
- **"One or more wallets share a funding source with one of your previous purchases"** — pick other wallets.

## See also

- [Folders](https://vortexdeployer.com/docs/wallets/groups)
- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)
- [Wallet warm-up](https://vortexdeployer.com/docs/wallets/warm-up)
- [Support](https://vortexdeployer.com/docs/account/support)
- [Wallet marketplace API](https://vortexdeployer.com/docs/api/marketplace)

---

# Folders

> Sort your pool wallets into folders, open one folder at a time, and act on a whole folder at once.

Source: https://vortexdeployer.com/docs/wallets/groups · Markdown: https://vortexdeployer.com/docs/wallets/groups.md

A [folder](https://vortexdeployer.com/docs/other/glossary#folder) is a named list of wallets, like "Launch A" or "Snipers". Use folders to sort your wallets and to act on one set at a time. Folders never move funds.

## Before you start

- Folders exist only in **Global wallets**, your [wallet pool](https://vortexdeployer.com/docs/other/glossary#wallet-pool). In **Project wallets** the left column lists projects instead.
- A wallet sits in one folder at most. A wallet in no folder is listed under **Unassigned**.

## The Folders column

On a wide screen, **Folders** is the left column of the Wallets page. On a narrow screen, press **Folders** to show it, or pick a folder from the list above the table.

- **All wallets** — every wallet in your pool.
- **Unassigned** — wallets that are in no folder.
- Then one row per folder, with its wallet count.
- **Search folders** finds a folder by name.

Click a row to open that folder. The table then shows only its wallets.

![Picking folders, then filtering the table by chain](https://vortexdeployer.com/docs/wallets/groups.mp4)

## Make a folder

1. Press **+** (**New folder**) at the top of the **Folders** column.
2. Type a name in **Folder name…**. Up to 64 characters.
3. Press Enter or the check mark (**Create folder**).

![The Folders column with a new folder name typed in](https://vortexdeployer.com/docs/wallets/groups.png)

Each folder name must be different from your other folders.

## Put wallets in a folder

- **One wallet:** click its **Folder** cell in the table, then pick a folder. Pick **Unassigned** to take it out.
- **Many wallets:** tick them, then use **Move to folder** in the bar above the table. **Unassign** sends them back to **Unassigned**. On a narrow screen these are **Assign folder…** and **Remove from folder** in the Actions panel.
- **New wallets:** open a folder before you press **New wallet**. The new wallets go straight into it. See [Create & import](https://vortexdeployer.com/docs/wallets/create-and-import).

A wallet file you saved when you [exported keys](https://vortexdeployer.com/docs/wallets/key-export) remembers each wallet's folder. Import it again, and missing folders are made for you.

Wallets you buy in the [Wallet Marketplace](https://vortexdeployer.com/docs/wallets/marketplace) arrive in a new folder for each order, named **Marketplace #** and 8 characters of the order ID.

## Rename or delete a folder

Open the folder. Hover over its row to show two buttons. On a touch screen they always show.

- **Rename folder** — type the new name, then press Enter.
- **Delete folder** — then press **Confirm?**.

Deleting a folder keeps every wallet in it. They move to **Unassigned**.

## Folders and projects

A folder is a label for you. A [project](https://vortexdeployer.com/docs/other/glossary#project) is a token launch, and its tasks trade from the project's wallets. One wallet can be in a folder and in several projects at the same time.

## Act on a whole folder

The Actions panel works on the wallets you ticked. With nothing ticked, it works on every wallet in view. So to fund, collect or warm up a whole folder, open it and press the action with nothing ticked. Check the count in **Funds (N)** before you start.

**Copy** above the table works the same way: with nothing ticked, it copies every address in view.

:::tip Check what is in view
Filters and search also limit what is in view. **Clear filters** shows the whole folder again.
:::

## See also

- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)
- [Fund wallets](https://vortexdeployer.com/docs/wallets/fund)
- [Collect funds](https://vortexdeployer.com/docs/wallets/collect)

---

# Fund wallets

> Send SOL or ETH into many wallets in one run, from a deposit address or from one of your wallets.

Source: https://vortexdeployer.com/docs/wallets/fund · Markdown: https://vortexdeployer.com/docs/wallets/fund.md

**Fund** fills many wallets at once. You send one amount, and the app splits it across the wallets you picked.

:::warning This moves real funds
Funding sends real SOL or ETH, and a payment that has gone out cannot be called back. Check the wallets, the amount and the fees first. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Before you start

- Open **Wallets**. Tick the wallets to fund, or tick none to fund every wallet in view. A [folder](https://vortexdeployer.com/docs/other/glossary#folder) or a [project](https://vortexdeployer.com/docs/other/glossary#project) narrows the view.
- One run funds wallets on one [chain](https://vortexdeployer.com/docs/other/glossary#chain). If the view has both chains, pick one under **Chain**.

## Pick a method

Press **Fund** in the Actions panel. **Fund wallets** opens. Pick the **Method**:

- **Vortex Disperse** — your money goes into a temporary deposit wallet. Short-lived in-between wallets then pay each of your wallets, so they are not paid straight from one shared wallet. See [Vortex Disperse](https://vortexdeployer.com/docs/other/glossary#vortex-disperse).
- **Mixer** — an outside exchange service, [Husher](https://vortexdeployer.com/docs/other/glossary#husher), pays each wallet after a wait. Each wallet must get at least 0.15 SOL (or 0.01 ETH). See [Mixer](https://vortexdeployer.com/docs/other/glossary#mixer).

![Ticking two wallets, opening Fund and switching the method. Nothing is sent.](https://vortexdeployer.com/docs/wallets/fund.mp4)

## Step 1: Amount and wallets

1. Check **Wallets to fund**. They all start ticked. Untick any to skip.
2. Enter the **Total SOL to deposit**. The default is 1.
3. Pick a **Distribution**:
  - **equal** — every wallet gets the same share.
  - **custom** — type an amount beside each wallet. The total is their sum.
  - **variation** — each share is a little bigger or smaller, at random. **Variation ± %** sets how much (1 to 100, default 20). The shares still add up to the total.
4. Optional: pick a **Supply plan** and press **Mount**. Each wallet that is short of its planned buy gets exactly what it is missing. **Manage plans** opens your plans.
5. Pick where the money comes from under **Fund from**:
  - **Deposit address · pay from anywhere** — you send the money from any wallet or exchange. This is the default.
  - One of your wallets — it must hold the whole total. A wallet with too little is marked _short_.
6. Optional, under **Advanced**: **Per-wallet delays** makes each wallet wait 0 to 1440 minutes before it is paid. **Auto-distribute** spreads the delays over the minutes in **Spread over**.

![The Fund wallets window for two ticked wallets](https://vortexdeployer.com/docs/wallets/fund.png)

The summary shows how much each wallet gets. For **Vortex Disperse** on Solana it also shows **Fees and reserve**: the exact SOL taken off before the split.

Then press **Get deposit address**, or **Start disperse** when one of your wallets pays. For **Mixer**, press **Next — exchanges & holds**.

## Step 2: Exchanges and holds (Mixer only)

Each wallet gets its own exchange and hold time. A hold is how many minutes the exchange keeps that share before it pays out. 0 pays as soon as your deposit is confirmed.

- **Randomize exchanges** mixes the exchanges across your wallets.
- **Auto-distribute holds** spreads the holds over the minutes beside it.

Then press **Create order — get deposit address**, or **Create order** when one of your wallets pays.

## Step 3: Pay and follow

If you chose a deposit address:

1. Send exactly the amount under **Send exactly** to the address shown. You can copy it or scan the QR code.
2. Follow the timeline: **Awaiting deposit**, **Funded**, **Distributing**, **Complete**. With Mixer it is **Awaiting deposit**, **Funds confirmed**, **Complete**.
3. With Mixer, **Execute now** on a row pays that wallet right away and skips its hold.

With **Vortex Disperse**, the deposit may be up to 0.005 SOL short (0.1 % on Robinhood).

If one of your wallets pays, there is nothing to send. Either way, the run is a [task](https://vortexdeployer.com/docs/other/glossary#task): closing the window does not stop it.

:::warning If the deposit does not arrive in time
The run waits 30 minutes for your deposit. After that it stops, and nothing has moved. The address still belongs to that run. Send the money to it, then start the task again.
:::

## Fees

- There is no [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee) on funding.
- **Vortex Disperse** — [network fees](https://vortexdeployer.com/docs/other/glossary#network-fee), the [rent](https://vortexdeployer.com/docs/other/glossary#rent) for the in-between wallets, and a small reserve come off your total before the split. The reserve, about 0.001 SOL, stays in the deposit wallet. On Robinhood, the gas for each wallet's hop comes off instead.
- **Mixer** — Husher takes its own fee out of the total. Each wallet gets its share after that fee.

:::info The deposit wallet
With **Vortex Disperse**, the deposit wallet shows in your wallet list with the role `disperser` while the run is going. If a run fails, it stays there. You can then [collect](https://vortexdeployer.com/docs/wallets/collect) its funds or [export its key](https://vortexdeployer.com/docs/wallets/key-export).
:::

## See also

- [Collect funds](https://vortexdeployer.com/docs/wallets/collect)
- [Mixer](https://vortexdeployer.com/docs/tasks/mixer)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)
- [Folders](https://vortexdeployer.com/docs/wallets/groups)

---

# Collect funds

> Pull SOL or ETH out of many wallets into one address, and choose what each wallet keeps.

Source: https://vortexdeployer.com/docs/wallets/collect · Markdown: https://vortexdeployer.com/docs/wallets/collect.md

**Collect** takes the SOL (or ETH) out of many wallets and sends it to one address. Use it to get your money back after a launch or a task.

:::danger A collection cannot be undone
Collect moves real funds. Funds sent to a wrong address are gone. Check the destination address before you confirm. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Before you start

- Collect moves SOL or ETH only. To turn tokens into SOL first, sell them, or use [Convert](https://vortexdeployer.com/docs/wallets/convert).
- One run collects from one [chain](https://vortexdeployer.com/docs/other/glossary#chain). If the view has both chains, pick one under **Chain**.

## Pick a method

Open **Wallets** and press **Collect** in the Actions panel. **Collect funds** opens. Pick the **Method**:

- **Sweep** — one transfer per wallet, straight to your destination. Works on both chains.
- **Mixer** — one [Husher](https://vortexdeployer.com/docs/other/glossary#husher) order per wallet. The exchange pays your destination, so the wallets are not linked to it by a direct transfer. Solana only. Pick the **Exchange**. Wallets with less than 0.15 SOL are skipped. Husher takes its own fee.

## Collect, step by step

1. **Destination wallet** — paste the address that receives the funds, or press **My wallets…** to pick one of yours. If you pick one of your wallets, it is not collected from.
2. **Select Wallets** — tick the wallets to collect from, or press **Select All**. Nothing is ticked at first. Only wallets that hold funds can be ticked.
3. Optional, beside each ticked wallet:
  - The amount box — blank (**All**) takes everything. **Max** fills in the wallet's balance.
  - **Keep** (Sweep only) — how much this wallet keeps.
4. Optional, under **Advanced**:
  - **Leave behind** (Sweep only) — how much every wallet keeps. A **Keep** figure beside a wallet wins. Blank or 0 takes everything down to the small floor.
  - **Delayed collection** — each wallet waits a random time between **Min (minutes)** and **Max (minutes)** before it goes. The default is 1 to 3 minutes, up to 1440. Wallets then go one at a time. **Roll again** picks new random waits. With Mixer, this sets how long each order is held instead.
5. Press **Collect funds** (or **Start delayed collection**, or **Collect via Mixer**).
6. **Confirm collection** shows the full address, the wallets and the amount. Read it, then press **Collect now**.

![The Collect funds window](https://vortexdeployer.com/docs/wallets/collect.png)

:::warning Do not send to an exchange deposit address
The app warns: do not withdraw directly to a [CEX](https://vortexdeployer.com/docs/other/glossary#cex), such as Binance or Coinbase. Collect to a wallet you control first, then send it on to the exchange. A [bonding curve](https://vortexdeployer.com/docs/other/glossary#bonding-curve) address is also refused.
:::

## What stays behind

Each wallet keeps a small floor, about 0.00089 SOL, for [rent](https://vortexdeployer.com/docs/other/glossary#rent). Each transfer also pays a small [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee). There is no [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee) on Collect.

## Follow the run

The window shows **Collection in progress**, with **Success**, **Failed** and **Skipped** counts, a line per wallet, and **Total collected**. Closing the window does not stop the run, because it is a [task](https://vortexdeployer.com/docs/other/glossary#task). To keep watching it, click the minimize button (**Minimize**) instead. The window then waits in the bottom bar as **Collect funds**, and one click opens it again.

## See also

- [Fund wallets](https://vortexdeployer.com/docs/wallets/fund)
- [Mixer](https://vortexdeployer.com/docs/tasks/mixer)
- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)

---

# Convert tokens

> Swap one token for another inside many Solana wallets at once, for example SOL to USDC or a token back to SOL.

Source: https://vortexdeployer.com/docs/wallets/convert · Markdown: https://vortexdeployer.com/docs/wallets/convert.md

**Convert** swaps a token inside each wallet you pick, for example SOL to USDC. The new tokens stay in the same wallet. Convert works on Solana wallets only.

:::warning Each conversion is a real trade
Convert spends real tokens and cannot be undone. The review step is free: no tokens move until you press **Convert N wallets**. There is no test mode. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Before you start

- Open **Wallets**. Tick the wallets to convert, or tick none to use every Solana wallet in view.
- Each wallet needs a little SOL for [network fees](https://vortexdeployer.com/docs/other/glossary#network-fee), even when it pays with another token.

## Convert, step by step

1. Press **Convert** in the Actions panel. **Convert tokens** opens, set to SOL to USDC.
2. Under **You pay**, press the token button and pick the token to pay with. The list shows only tokens your wallets hold, with how much they hold in total.
3. Enter the **Amount per wallet**. Each wallet pays this amount. Or tick **All available in each wallet**.
4. Under **You receive**, pick the token you want. If it is not listed, paste its [mint address](https://vortexdeployer.com/docs/other/glossary#mint-address) and press **Find token by address**.
5. Press **Review conversion**. The app checks each wallet's trade. **Stop after this wallet** stops the check.
6. Read the result: how many wallets are ready, **Total you pay** and **Minimum you receive**. Wallets that are not ready are skipped.
7. Press **Convert N wallets**.

![The Convert tokens window before the review](https://vortexdeployer.com/docs/wallets/convert.png)

The **You receive** list has SOL, the [stablecoins](https://vortexdeployer.com/docs/other/glossary#stablecoin) USDC and USD1, [stock tokens](https://vortexdeployer.com/docs/other/glossary#stock-token), and every token your wallets hold. The arrow button between the two boxes switches them.

Changing a token, the amount, the wallets or a limit clears the review. Press **Review conversion** again.

## Your wallets

The **Your wallets** list beside the form shows each wallet's SOL and tokens.

- Tick or untick wallets here. **Select all** and **Clear all** work on the whole list.
- Click a token under a wallet to convert just that token from just that wallet.
- After the review, each wallet shows **Receive ≈**, its minimum and its [price impact](https://vortexdeployer.com/docs/other/glossary#price-impact). A wallet that will be skipped shows **Skipped:** and the reason.

## Follow the run

When you press **Convert N wallets**, the window closes and the run opens as an [operation](https://vortexdeployer.com/docs/account/operations) called **Token conversion**. It is saved to your account, and it keeps going if you close the tab.

Each wallet is one line. Its status is **Queued**, **In progress**, **Awaiting confirmation**, **Completed**, **Needs attention** or **Stopped**.

- **Stop remaining items** stops the wallets that have not started. A wallet that already started may still finish.
- If a wallet needs attention, read its line first. **Continue remaining items** then starts the wallets that are still queued.
- **Open wallet** opens that wallet's own page.

## Options

Under **Advanced**:

- **Slippage limit (%)** — how far the price may move after the review before a trade is refused. Default 1, from 0.01 to 5. See [slippage](https://vortexdeployer.com/docs/other/glossary#slippage).
- **Price impact limit (%)** — a wallet whose trade would move the price more than this is skipped. Default 3, from 0.01 to 5.

## Wrapped SOL back to SOL

[Claimed cashback](https://vortexdeployer.com/docs/wallets/cashback) arrives as [wrapped SOL](https://vortexdeployer.com/docs/other/glossary#wrapped-sol) (WSOL). To turn it into plain SOL, pick **WSOL** under **You pay** and **SOL** under **You receive**. One WSOL gives one SOL. WSOL can only be converted to SOL.

## Fees

- There is no [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee) on Convert.
- Each wallet pays its own network fee.
- When you pay with SOL, a little SOL stays in each wallet for fees and token accounts.
- A wallet that has never held the token you receive needs a new token account. That costs about 0.002 SOL of [rent](https://vortexdeployer.com/docs/other/glossary#rent), which stays in the wallet.

## Troubleshooting

- **"No … in this wallet"** — that wallet holds none of the token you pay with. It is skipped.
- **"Wallet needs at least … SOL for transaction fees and token accounts"** — send that wallet a little SOL with **Transfer** or [Fund](https://vortexdeployer.com/docs/wallets/fund), then review again.
- **"Price impact … exceeds your …% limit"** — the trade is too big for the pool. Lower the amount, or raise **Price impact limit (%)**.
- **"Price changed since review"** — press **Review conversion** again, then convert.

## See also

- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)
- [Operation progress](https://vortexdeployer.com/docs/account/operations)
- [Claim cashback](https://vortexdeployer.com/docs/wallets/cashback)
- [Collect funds](https://vortexdeployer.com/docs/wallets/collect)

---

# Claim cashback

> Claim the cashback your Solana wallets earned from trades on cashback coins. It arrives as wrapped SOL.

Source: https://vortexdeployer.com/docs/wallets/cashback · Markdown: https://vortexdeployer.com/docs/wallets/cashback.md

Some pump.fun coins are cashback coins. When one of your wallets trades such a coin on [PumpSwap](https://vortexdeployer.com/docs/other/glossary#pumpswap), part of the trading fee is set aside for that wallet as [cashback](https://vortexdeployer.com/docs/other/glossary#cashback). It is not sent to the wallet by itself. **Claim cashback** moves it into your wallets.

New coins can no longer turn cashback on. This page is for coins that already have it.

## Claim

1. Open **Wallets**. Tick the wallets to check, or tick none to check every Solana wallet in view.
2. Press **Claim cashback** in the Actions panel.
3. **Wallets with cashback** lists each wallet that has cashback waiting. They all start ticked. Untick any you want to skip, or use **Select all** and **Clear all**.
4. Check the summary: **Claim** (the total SOL), **Wallets**, and **New wSOL accounts**.
5. Press **Claim now**. A confirm shows the total and the number of wallets. Confirm to claim. The claim is real. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).

![The Claim cashback window](https://vortexdeployer.com/docs/wallets/cashback.png)

If no wallet in view has cashback, the window says: "None of the wallets in view has cashback to claim."

## What a claim does

- The cashback lands in each wallet as [wrapped SOL](https://vortexdeployer.com/docs/other/glossary#wrapped-sol) (wSOL). It is not turned back into plain SOL, and nothing is closed. To get plain SOL, use [Convert](https://vortexdeployer.com/docs/wallets/convert): pay with **WSOL**, receive **SOL**.
- Each wallet pays its own [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee) for its claim.
- A wallet with no wSOL account gets one. That costs about 0.002 SOL of [rent](https://vortexdeployer.com/docs/other/glossary#rent), which stays in the wallet as part of that account.
- There is no [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee) on a claim.

## Troubleshooting

- **Nothing to claim** — cashback comes only from PumpSwap trades on cashback coins. Trades on other coins do not earn it.

## See also

- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)
- [Convert tokens](https://vortexdeployer.com/docs/wallets/convert)
- [Collect funds](https://vortexdeployer.com/docs/wallets/collect)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)

---

# Wallet warm-up

> Give new wallets a trading history with real small trades, or give a dev wallet a history of real launches.

Source: https://vortexdeployer.com/docs/wallets/warm-up · Markdown: https://vortexdeployer.com/docs/wallets/warm-up.md

A brand-new wallet with no history stands out. A [warm-up](https://vortexdeployer.com/docs/other/glossary#warm-up) makes real small trades with your wallets, so they have a history before you use them. **Dev warmup** does the same for a [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet), with real token launches.

:::warning Warm-ups spend real money
Every warm-up trade is a real buy or sell. It pays the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee) and [network fees](https://vortexdeployer.com/docs/other/glossary#network-fee), and a coin can lose value while a wallet holds it. A dev warmup launches real tokens. Keep enough SOL or ETH in each wallet. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Warm up wallets

1. Open **Wallets**. Tick the wallets to warm up, or tick none to use every wallet in view. All of them must be on one [chain](https://vortexdeployer.com/docs/other/glossary#chain).
2. Press **Warm up** in the Actions panel. **Warm up wallets** opens.
3. Pick the **Tokens to warm on**:
  - **Auto (warmup cache)** — the app picks a different live coin for each buy: a [pump.fun](https://vortexdeployer.com/docs/other/glossary#pump-fun) coin on Solana, a pons coin on Robinhood. The box under it shows how many coins can be picked right now.
  - **One token** — every trade uses one coin. Paste its **Token mint** (on Robinhood, **Token address**). See [mint address](https://vortexdeployer.com/docs/other/glossary#mint-address).
4. Set **Buy per wallet (SOL)**, **Hold time (seconds)**, **Trades per cycle** and **Cycles (0 = until stopped)**. [Wallet warm-up task](https://vortexdeployer.com/docs/tasks/wallet-warmup#settings) explains each setting and how a run trades.
5. Press **Start warmup**. A confirm shows how much each buy spends. Confirm to start.

![The Warm up wallets window](https://vortexdeployer.com/docs/wallets/warm-up.png)

The summary shows **Wallets**, **Each buy** and **Trades per wallet**.

### Stop a warm-up

A warm-up runs as a [task](https://vortexdeployer.com/docs/other/glossary#task). To stop it, open **Warm up** again. **Running warmups** lists your runs. Click one to open its task card, then press **Stop** there.

## Dev warmup

Dev warmup gives one dev wallet a history of real launches. It needs the highest [tier](https://vortexdeployer.com/docs/other/glossary#tier). Below that tier the button is greyed out and shows **Highest tier required**.

1. Press **Dev warmup** in the Actions panel.
2. Pick the **Chain**: **Solana** or **Robinhood**.
3. Tick the **Dev wallet (exactly one)**.
4. Set **Tokens to launch (1–20)**. The default is 3.
5. Optional: tick **Custom metadata** to launch one token with your own image (PNG, JPG, GIF or WEBP, up to 5 MB), name, symbol and links. Without it, each Solana token copies the look of a recent pump.fun coin, and each Robinhood token gets a new name.
6. Check the cost in the summary. Press **Start dev warmup** and confirm.

**Recent warmups** lists your last runs.

### What it costs

The dev wallet pays for every launch.

- **Solana** — about 0.028 SOL per token (**Estimated cost**). Each token is made on Meteora, bought out in one buy, then moved to a trading pool. See [migration](https://vortexdeployer.com/docs/other/glossary#migration).
- **Robinhood** — each token gets a 0.0000011 ETH bid from the dev wallet. Allow about 4 minutes per token. The **Spend cap** is 0.0015 ETH per token, gas included. Bid money that is not used comes back. Listings and badges on outside sites are not guaranteed.

## See also

- [Wallet warm-up task](https://vortexdeployer.com/docs/tasks/wallet-warmup)
- [Fund wallets](https://vortexdeployer.com/docs/wallets/fund)
- [Best practices](https://vortexdeployer.com/docs/other/best-practices)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)

---

# Export a private key

> Show and save the private key of one wallet or many, so you can use the wallet in another app.

Source: https://vortexdeployer.com/docs/wallets/key-export · Markdown: https://vortexdeployer.com/docs/wallets/key-export.md

A [private key](https://vortexdeployer.com/docs/other/glossary#private-key) is the secret that controls a [wallet](https://vortexdeployer.com/docs/other/glossary#wallet). Export it to open the wallet in Phantom, MetaMask or another app, or to keep a backup. The app never shows a key unless you export it.

:::danger Anyone with the key owns the wallet
The app shows this warning every time:

> Anyone with this private key has full control of this wallet and everything in it. Never share it, never paste it into a website, and store it somewhere only you can reach.

A key cannot be changed. If someone else gets it, the only fix is to move the funds to a new wallet before they do.
:::

## Export one key

1. Open **Wallets**. Press **⋯** at the end of the wallet's row, then **Export key**. **Export private key** opens.
2. Type your **Account password**. Fill it in only if you set a web-login password in this app. If you sign in with Telegram only, leave it blank. A password from the old site does not count.
3. Press **Reveal private key**.
4. The key appears hidden. Press **Show** to see it, or press the copy button next to it.
5. Paste the key where it goes, then clear your clipboard.
6. Press **Done — I’ve saved it**.

![The Export private key window with its warning, before any key is shown](https://vortexdeployer.com/docs/wallets/key-export.png)

A Solana wallet shows the same key in two forms:

- **Private key (base58 — Phantom / CLI)** — for Phantom and most Solana apps. See [base58](https://vortexdeployer.com/docs/other/glossary#base58).
- **Byte array (solana-keygen JSON)** — for command-line tools.

A Robinhood wallet shows **Private key (hex — MetaMask / Rabby · Robinhood)**.

## Export many keys

1. Tick the wallets. Press **Export keys** in the bar above the table (or in the Actions panel on a narrow screen).
2. Type your **Account password**, then press **Reveal N private keys**.
3. Each wallet is listed with its key hidden. **Show all** shows every key. **Find exported wallet** searches the list.
4. **Copy all** copies every wallet as one line each: the address, a comma, then the key.
5. Press **Done — I’ve saved them**.

## Download a wallet file

After a reveal, **Download file** saves the keys in one JSON file. The file also keeps each wallet's role, label and folder. You can load it back later with **Import from file** under **New wallet**. See [Create & import](https://vortexdeployer.com/docs/wallets/create-and-import).

:::warning The file holds your keys in plain text
Anyone who opens the file can take every wallet in it. Keep it offline, for example on a USB stick. Do not email it or upload it to cloud storage.
:::

## Good to know

- If you type a wrong password too many times, exports pause for a while. The window says how long.
- Every export is recorded on your account.
- Once a key has left the app, treat it as possibly seen. When you are done with the other app, move the funds back to a wallet made here.

## See also

- [Create & import](https://vortexdeployer.com/docs/wallets/create-and-import)
- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)
- [Sign in & accounts](https://vortexdeployer.com/docs/overview/sign-in)
- [Best practices](https://vortexdeployer.com/docs/other/best-practices)

---

# Create a project

> Launch a new token step by step with the Create Project wizard.

Source: https://vortexdeployer.com/docs/launch/create-project · Markdown: https://vortexdeployer.com/docs/launch/create-project.md

A [project](https://vortexdeployer.com/docs/other/glossary#project) is one token you launch, plus the wallets and tasks that trade it. The **Create Project** wizard walks you through it in four steps. For a fast launch from saved settings, use [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy) instead.

## Before you start

- Have at least one wallet with SOL (or ETH on [Robinhood Chain](https://vortexdeployer.com/docs/other/glossary#robinhood-chain)). See [Fund wallets](https://vortexdeployer.com/docs/wallets/fund).
- Have your token image, name and symbol ready.

:::warning This spends real money
The wizard has no test mode. **Create** and **Schedule** send real transactions and spend real SOL or ETH. No confirm window opens after you press them. Read [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run) first.
:::

## Open the wizard

1. Click **Create Project** at the top of the app. On a narrow screen the button reads **Create**.
2. Or open **Projects** and click **Create Project**.

The **Create Project** window opens on step 1. You can jump between steps at any time.

## The four steps

1. **Metadata** — the token's image, name, symbol, links and [launchpad](https://vortexdeployer.com/docs/other/glossary#launchpad). See [Token details](https://vortexdeployer.com/docs/launch/token-details) and [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings).
2. **Wallets** — pick the [creator wallet](https://vortexdeployer.com/docs/other/glossary#creator-wallet), set the [dev buy](https://vortexdeployer.com/docs/other/glossary#dev-buy) and add trading wallets. See [Wallets step](https://vortexdeployer.com/docs/launch/wallets-step).
3. **Tasks** — optional. Add tasks that trade the token the moment it launches. See [Tasks step](https://vortexdeployer.com/docs/launch/tasks-step).
4. **Review & Deploy** — check everything, set **Launch at** and **Launches**, then launch.

![A draft walked through Metadata, Wallets, Tasks and Review & Deploy. Nothing is launched.](https://vortexdeployer.com/docs/launch/create-project.mp4)

## Your draft is saved for you

The wizard saves your work as a [draft](https://vortexdeployer.com/docs/other/glossary#draft) while you type. The top of the window shows **Unsaved draft**, **Saving…**, **Saved** or **Not saved**.

- **Save & close**, **Cancel**, the **×** and the Escape key all close the window and keep the draft.
- A click outside the window does not close it, so you cannot lose your work by accident.
- To go on later, open **Projects**, pick the **Drafts** tab and click **Resume**.

The **Wallets** step unlocks once the draft exists. Until then it says "Preparing the project…" and offers **Retry**.

## The left column

On a wide screen, a column on the left stays with you through all four steps:

- Your token's image and name, and its reserved address (**CA**). Click the address to copy it.
- **Reuse** — fill the whole wizard from one of your past launches, tasks included.
- **Vamp** — copy another token's look. See [Clone a token](https://vortexdeployer.com/docs/launch/clone-token).
- A short summary of each step.
- **Per launch** — the **Dev buy** and **Task buys** one launch spends. Fees and rent are extra. With more than one launch it shows "× N launches".

![A draft open on Metadata, with the left column and the step list](https://vortexdeployer.com/docs/launch/create-project.png)

## Launch

1. Go to **Review & Deploy**.
2. If the page lists "Before you can launch, add:", fix each item first. Each one ends in **Fix**. Click it to jump to the step that needs it.
3. Check the **Token**, **Wallets** and **Launch tasks** blocks. Click **Edit** on a block to change it.
4. Leave **Launch at** empty to launch now, or pick a time to schedule it.
5. Click **Create**. When **Launch at** is set, the button reads **Schedule**.

After **Create**, the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal) opens right away and says **Preparing** with your symbol. See [After launch](https://vortexdeployer.com/docs/launch/after-launch) for what comes next.

:::danger Never launch twice by mistake
If you see "Launch confirmation pending", do not press **Create** again. Your first launch may still land. Check **Projects** first.
:::

## Troubleshooting

- **Create is greyed out** — something is still missing. Hold the pointer over the button to see "Missing:" and the list, or read "Before you can launch, add:" on **Review & Deploy**. **Create** works again once the list is empty.
- **"Pick a creator wallet"** — go to the **Wallets** step and choose a dev wallet.
- **"Add a token image"** — upload an image on the **Metadata** step.
- **The Wallets step stays locked** — the draft could not be made. Click **Retry**.

## See also

- [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy)
- [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings)
- [After launch](https://vortexdeployer.com/docs/launch/after-launch)
- [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run)

---

# Quick deploy

> Launch a token from one small window, using settings you saved ahead of time.

Source: https://vortexdeployer.com/docs/launch/quick-deploy · Markdown: https://vortexdeployer.com/docs/launch/quick-deploy.md

Quick deploy launches a token from one small window, on any page. You save your usual setup once as a [preset](https://vortexdeployer.com/docs/other/glossary#preset). After that, a launch needs only a name and a click.

## Before you start

- Have a wallet with SOL (or ETH on [Robinhood Chain](https://vortexdeployer.com/docs/other/glossary#robinhood-chain)). See [Fund wallets](https://vortexdeployer.com/docs/wallets/fund).
- Set up at least one preset, as shown below.

:::warning Deploy spends real money
**Deploy** sends a real launch right away. It spends real SOL or ETH, and no confirm window opens first. There is no test mode here. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Set up your presets

You can keep three presets: **PRESET 1**, **PRESET 2** and **PRESET 3**. Each one holds a full launch setup.

1. Open **Settings** and pick **Quick deploy**. Or click **Settings** at the top of the Quick deploy window.
2. Pick the tab of the preset you want to change.
3. Fill in the groups:
   - **Launchpad** — where the token launches, its [pair token](https://vortexdeployer.com/docs/other/glossary#pair-token) and its mode. See [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings).
   - **Token** — the **Default symbol** and **Default image**, used when you leave them empty.
   - **Dev wallet and dev buy** — the **Default dev wallet** and the **Dev buy**. Pick **Choose at launch** to choose the wallet each time.
   - **Launch tasks** — click **Add launch task** for tasks that start when the token exists. Up to 20.
4. Click **Save PRESET 1** (or 2, or 3). You see "PRESET 1 saved — Quick deploy uses it".

Under **Advanced** you can change the dev buy's [slippage](https://vortexdeployer.com/docs/other/glossary#slippage) (default 5%) and [priority fee](https://vortexdeployer.com/docs/other/glossary#priority-fee) (default 100,000). Most people leave these alone.

## Launch a token

1. Click **Quick** at the bottom of the app. On a phone, open the menu and pick **Quick deploy**.
2. The **Quick Deploy** window opens. Pick **PRESET 1**, **PRESET 2** or **PRESET 3** at the top. The one you pick is also used next time.
3. Type a **Name**. Leave **Symbol** empty to use the preset's symbol, or one made from the name.
4. Optional: choose a **Token image** (PNG, JPEG, GIF or WebP, up to 5 MB), or click **ASCII art**. With no image, the preset's image is used. If the preset has none, an image is drawn from the symbol.
5. Check the **Creator wallet**, the **Dev buy** and **Launches**. They come from the preset. You can change them for this launch.
6. Check the **Launch tasks** box. It lists each task from the preset and its wallets. Untick it to launch without them.
7. Click **Deploy**.

![The Quick Deploy window](https://vortexdeployer.com/docs/launch/quick-deploy.png)

If the preset names no creator wallet, or a task has no wallets, the window changes to **Choose for this launch**. Pick the missing wallets, then click **Deploy**. Tick **Save to PRESET 1** (or 2, or 3) to keep these picks for next time. **Back** returns to the form.

The [terminal](https://vortexdeployer.com/docs/other/glossary#terminal) opens as soon as the launch is sent. You see "Launch sent — opening" with your symbol, then **Token minted!** or a "Mint failed" message. See [After launch](https://vortexdeployer.com/docs/launch/after-launch).

## Other buttons

- **Vamp** — copy another token's name, symbol and image. Its description and links are kept only in the full wizard. See [Clone a token](https://vortexdeployer.com/docs/launch/clone-token).
- **Reuse** — fill the window from one of your past launches. The launch tasks stay the ones from your preset.
- **Full wizard** — move to the [Create Project](https://vortexdeployer.com/docs/launch/create-project) wizard. Your name, symbol, image, launchpad, creator wallet, dev buy and ticked launch tasks come with you. Pick another preset under **Quick deploy preset** on the first step to swap them.
- **Custom token address** — launch on an address you made yourself. See [Token details](https://vortexdeployer.com/docs/launch/token-details).

## Troubleshooting

- **Deploy is greyed out** — something is still missing. The first reason shows next to the button, such as "Add a token name". Fix it, and the next one shows, until **Deploy** works.
- **"Fund it (Wallets → Funds) before launching"** — the creator wallet cannot pay for the dev buy. Add SOL to it, or lower the dev buy.
- **Your saved dev wallet is gone** — it was deleted or is on another chain. Pick a new one and save the preset again.
- **"Pick the stock the StonkFun curve is quoted in"** — the preset uses StonkFun but names no stock. Pick one under **Launchpad** in the window. To keep it, pick it in **Settings** → **Quick deploy** too.
- **"… does not offer Community mode — pick Standard or Reward, or another stock"** — the preset uses StonkFun **Community** with a stock that does not offer it. Pick another **Mode** or stock under **Launchpad**. See [StonkFun options](https://vortexdeployer.com/docs/launch/launch-settings#stonkfun-options).

## See also

- [Create a project](https://vortexdeployer.com/docs/launch/create-project)
- [Deploy from XID](https://vortexdeployer.com/docs/xid/deploy)
- [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings)
- [Settings](https://vortexdeployer.com/docs/account/settings)
- [After launch](https://vortexdeployer.com/docs/launch/after-launch)

---

# Token details

> Fill in step 1 of the wizard, the token's name, symbol, image, links and address.

Source: https://vortexdeployer.com/docs/launch/token-details · Markdown: https://vortexdeployer.com/docs/launch/token-details.md

Step 1, **Metadata**, is what buyers see: your token's image, name, symbol and links. You need a name, a symbol and an image. Everything else is optional.

## Start from a past launch or another token

- **Reuse** — fills the whole wizard from your latest launch. The arrow next to it lists older ones. It copies the details, launchpad, wallets, dev buy and tasks. Your old project does not change.
- **Vamp** — copies another token's name, symbol, description, links and image. See [Clone a token](https://vortexdeployer.com/docs/launch/clone-token).

Until you have launched a token, the button reads **Reuse · none yet**.

## Fill in the token

1. **Token image** — click **Upload**, or drag a file onto the square. PNG, JPG, GIF or WEBP, up to 5 MB. Large pictures are shrunk to 512 × 512. GIFs are kept as they are. Hover the image and click **Change** to swap it.
2. No image? Click **ASCII art**. Type a short text, pick a **Style** and colours, then click **Select**. It becomes a 512 × 512 image.
3. **Name** — up to 32 bytes. Most letters count as one byte. Emoji and accented letters count as more.
4. **Symbol** — the short ticker, up to 10 bytes.
5. **Description** — optional, up to 500 characters.
6. **Links** — optional **Website**, **X** and **Telegram**.
7. **Launchpad** — pick where the token launches and its [pair token](https://vortexdeployer.com/docs/other/glossary#pair-token). See [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings) and [Pair tokens](https://vortexdeployer.com/docs/launch/pair-tokens).

![Token image, Name, Symbol, Description and Links on the Metadata step](https://vortexdeployer.com/docs/launch/token-details.png)

:::warning Check before you launch
The name, symbol and image go on the chain at launch. The app cannot change them afterwards.
:::

## Your reserved address

Every token has a [contract address](https://vortexdeployer.com/docs/other/glossary#contract-address), often called the **CA**. On **Pump.fun**, **LaunchLab**, **Bonk** and **Bonkers**, the wizard reserves one for you while you fill in the form.

- It shows in the left column with "Reserved for you · click to copy". Click it to copy the address.
- Your token lands on that address. With more than one launch, only the first launch uses it.
- Click **Refresh contract address** (the circular arrow) to get a new one.

On **StonkFun**, **Bags** and **pons**, the launchpad gives the address at launch.

## Custom token address

You can launch on a [vanity address](https://vortexdeployer.com/docs/other/glossary#vanity-address) you made yourself, for example one that ends in "pump". This works on Solana only.

1. Make a keypair with a tool such as `solana-keygen grind`.
2. Paste its secret into **Custom token address**. Base58, a JSON array or base64 all work.
3. The field shows "Lands on" and the address it will use.

- A custom address fits one launch only, so **Launches** must be 1.
- If the address already exists on the chain, pick another keypair.
- Leave the field empty to use your reserved address.

:::danger Keep the secret safe
The keypair secret controls that token address. Paste it only here, and never share it.
:::

## Troubleshooting

- **"Image must be ≤ 5 MB"** — pick a smaller file.
- **A red line says the name or symbol is too long** — it counts bytes, not letters. Shorten it or remove emoji.
- **"No contract address was reserved"** — click **Refresh contract address** to try again.

## See also

- [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings)
- [Pair tokens](https://vortexdeployer.com/docs/launch/pair-tokens)
- [Wallets step](https://vortexdeployer.com/docs/launch/wallets-step)
- [Chains & launchpads](https://vortexdeployer.com/docs/overview/chains-and-launchpads)

---

# Wallets step

> Pick the creator wallet, set the dev buy and add trading wallets in step 2 of the wizard.

Source: https://vortexdeployer.com/docs/launch/wallets-step · Markdown: https://vortexdeployer.com/docs/launch/wallets-step.md

Step 2, **Wallets**, picks the wallets for this launch. The [creator wallet](https://vortexdeployer.com/docs/other/glossary#creator-wallet) makes the token and pays the launch fee. Trading wallets are the ones your launch tasks buy and sell with.

![The Wallets step: the creator wallet, the dev buy and the buying wallets](https://vortexdeployer.com/docs/launch/wallets-step.png)

Every wallet you add here becomes a [project wallet](https://vortexdeployer.com/docs/other/glossary#project-wallet). It shows under this project on the **Wallets** page.

## Pick the creator wallet

1. Click the **Dev** tile, or the **Choose creator wallet** card.
2. Pick **Create new** to make a fresh wallet, or **Import private key** to use one you have.
3. To use a wallet already in the list, click **Make dev** on its row. The old creator becomes a normal trading wallet.

## Add trading wallets

The tiles along the top add wallets:

- **Create** — makes new wallets. Type the **Number of wallets**. Add an optional **Naming pattern**, such as `Volume #{n}`. The `{n}` becomes 1, 2, 3 and so on.
- **Import** — paste **Private keys**, one per line. They are stored encrypted, for this project only.
- **Global** — add wallets from your [wallet pool](https://vortexdeployer.com/docs/other/glossary#wallet-pool), one by one or a whole group with **Assign a group**. They stay in the pool, so other projects can use them too.
- **Fund** — send SOL or ETH to the project wallets. See [Fund wallets](https://vortexdeployer.com/docs/wallets/fund). It is greyed out until the project has a wallet.

Next to the tiles you see the total balance of all project wallets. The list below has two parts: **Creator wallet** and **Trading wallets**. Use **Find project wallet** to search it.

Trading wallets are optional. You can launch with only a creator wallet.

## Set the dev buy

The [dev buy](https://vortexdeployer.com/docs/other/glossary#dev-buy) is the amount the creator wallet buys in the same transaction that makes the token. It makes the creator the first holder. Leave it empty for no dev buy.

1. Find the **Dev buy** box on the creator wallet's row.
2. Type an amount, or click **Max**.

- **Max** — fills in what the creator can spend. It keeps 0.045 SOL per launch for fees and rent. It works for SOL only.
- **Limits** — up to 85 SOL, 10 ETH, or 1,000,000 USDC or USD1.

Where the money comes from depends on your [pair token](https://vortexdeployer.com/docs/other/glossary#pair-token):

- **SOL or ETH** — the creator spends its own SOL or ETH.
- **USDC or USD1** — the creator must already hold that coin. The launch does not swap for it. Use **Convert** on the **Wallets** page first.
- **A stock or pump coin on Pump.fun, or a StonkFun stock** — you type the amount in SOL. The launch swaps it into the pair token for you. The creator only needs SOL.
- **USDG or a stock on pons** — you type the amount in ETH. It is swapped into the pair token before the buy, with a 1% swap fee.

See [Pair tokens](https://vortexdeployer.com/docs/launch/pair-tokens) for more.

:::warning The dev buy is real money
The dev buy spends real SOL or ETH the moment the token launches. It cannot be undone. Fees and rent come on top of it. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::info When the creator trades
Launch tasks trade from the trading wallets. The creator joins a task only when you switch it on in that task. A Bundle never uses the creator.
:::

## Remove a wallet

Click the remove button on a row. The wallet leaves this project and stays in your global pool, with its key and balance. It is never deleted.

## See also

- [Tasks step](https://vortexdeployer.com/docs/launch/tasks-step)
- [Pair tokens](https://vortexdeployer.com/docs/launch/pair-tokens)
- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)
- [Fund wallets](https://vortexdeployer.com/docs/wallets/fund)

---

# Tasks step

> Add launch tasks in step 3 of the wizard, so your wallets trade the token the moment it exists.

Source: https://vortexdeployer.com/docs/launch/tasks-step · Markdown: https://vortexdeployer.com/docs/launch/tasks-step.md

Step 3, **Tasks**, gives your launch its first buyers. A [launch task](https://vortexdeployer.com/docs/other/glossary#launch-task) is a normal [task](https://vortexdeployer.com/docs/tasks/overview) that is tied to this launch and can start the moment the token exists.

Tasks are optional. Without one, the launch only makes the token, plus the dev buy if you set one.

## Before you start

Add trading wallets on the [Wallets step](https://vortexdeployer.com/docs/launch/wallets-step). Tasks pick their wallets from there. The creator wallet does not count.

## Add a task

1. With no task yet, the list of tasks is already open. Click one to add it.
2. To add another, click **Add task**.
3. Fill in the card. It has the same settings as [New task](https://vortexdeployer.com/docs/tasks/overview), with your project wallets on the side.
4. Pick the wallets that should trade, and the amount for each.

![The Tasks step of the wizard](https://vortexdeployer.com/docs/launch/tasks-step.png)

The two launch buys come first in the list:

- **Bundle** — your wallets buy in the same moment as the launch. Solana only. See [Bundle](https://vortexdeployer.com/docs/tasks/bundle).
- **Snipe** — your wallets buy right after the token appears. See [Snipe](https://vortexdeployer.com/docs/tasks/snipe).

Most other tasks follow, such as **Volume**, **Buy**, **Limit order** and **Holder Boost**. Migrate & Buy, Wallet Warmup and Mixer are not offered here.

Amounts on the cards are in SOL (or ETH on Robinhood Chain), even when the token has another [pair token](https://vortexdeployer.com/docs/other/glossary#pair-token).

## Auto-start at launch

Every card has an **Auto-start at launch** switch:

- **On** — the task starts the moment the token exists. A Bundle on Solana goes out together with the launch itself.
- **Off** — the task is made but paused. Start it later from the terminal.

:::warning Auto-start tasks spend real money
When you press **Create**, every task with **Auto-start at launch** on buys with real SOL or ETH. Each buy also pays the platform fee. See [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees) and [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Bundle details

- A Bundle never uses the creator wallet. Add at least one other wallet on step 2.
- With many buyers, a Bundle may need a [lookup table](https://vortexdeployer.com/docs/other/glossary#lookup-table). A **Lookup table** box shows up only when one is needed.
- **Allow automatic lookup-table setup** lets the app make the table from the dev wallet before you press **Create**. The card shows the most it can spend and how many buyers fit. Unused money stays in the wallet. The rent comes back when the table is closed.
- A table made for a launch that never happens is closed after a day. Its rent goes back to the dev wallet.

## Supply estimate

On **Snipe**, **Buy** and **Bundle** cards, **Supply estimate** shows the share of the token each wallet would get. Click **Calculate supply %** to work it out.

It is a best case. It assumes nobody else buys in between. Your real share can only be lower.

## Robinhood Chain limit

On Robinhood Chain, at most 31 wallets can buy the instant the token launches, across all Snipe and instant Buy tasks. With more, **Create** stays greyed out. Remove some wallets, or give them a Buy task with a delay.

## Troubleshooting

- **"No bundle wallets"** — add a wallet other than the dev wallet on step 2.
- **A card says it is not complete** — open it and fill in the field shown in red.

## See also

- [Bundle](https://vortexdeployer.com/docs/tasks/bundle)
- [Snipe](https://vortexdeployer.com/docs/tasks/snipe)
- [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)

---

# Launch settings

> Choose the launchpad, pair token, mode and fees, and set the dev buy, launch time and number of launches.

Source: https://vortexdeployer.com/docs/launch/launch-settings · Markdown: https://vortexdeployer.com/docs/launch/launch-settings.md

These settings decide how your token launches: where, in which coin, with which fee rules, when, and how many times. You set them on step 1 (**Metadata**) and step 4 (**Review & Deploy**) of the wizard. [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy) keeps the same settings in its presets.

![The Review & Deploy step](https://vortexdeployer.com/docs/launch/launch-settings.png)

## Launchpad

The [launchpad](https://vortexdeployer.com/docs/other/glossary#launchpad) is the site your token launches on. The tile you pick also sets the chain.

- **Pump.fun** — Solana. Pairs: SOL, USDC or **Custom pairs**.
- **LaunchLab** (Raydium), **Bonk** and **Bonkers** — Solana. Pairs: SOL or USD1.
- **StonkFun** — Solana. Paired with a [tokenized stock](https://vortexdeployer.com/docs/other/glossary#tokenized-stock).
- **Bags** — Solana. SOL only.
- **pons** — [Robinhood Chain](https://vortexdeployer.com/docs/other/glossary#robinhood-chain). Pairs: ETH, USDG, stocks or **Custom CA**.

The **Quote** row picks the [pair token](https://vortexdeployer.com/docs/other/glossary#pair-token), the coin your token is priced in. See [Pair tokens](https://vortexdeployer.com/docs/launch/pair-tokens) for what each one means.

## Pump.fun options

- **Mode** — **Classic** (default) or **Mayhem**, pump.fun's own launch mode. Mayhem needs a SOL or USDC pair.
- **Fees** — who gets the [creator fees](https://vortexdeployer.com/docs/other/glossary#creator-fees) from trading:
  - **Creator Fees** (default) — they go to you, the creator.
  - **Holder Rewards** — they go to holders, paid by pump.fun in the pair token. Holders need more than $20 worth. Nobody has to claim.
- **Custom-pair fee (%)** — only with **Custom pairs**. The creator fee each trade pays. From 0.01% to 3%, default 1%. With SOL or USDC, pump.fun's standard fees apply instead.
- **OTC Desks** — only with a SOL pair and **Creator Fees**. See [OTC Desks pairing](https://vortexdeployer.com/docs/launch/otc-desks).

:::warning Some choices are final
**Holder Rewards** is permanent. The **Custom-pair fee** is final at launch and cannot be changed.
:::

## StonkFun options

1. Pick the stock your token is paired with. See [StonkFun stocks](https://vortexdeployer.com/docs/launch/pair-tokens#stonkfun-stocks).
2. Pick a **Mode**:
   - **Standard** — a plain token with no tax.
   - **Reward** — a tax on every transfer of your token. StonkFun pays it out to holders.
   - **Community** — the same tax. StonkFun pays part of it to the stock's holders and the rest to your token's holders. It shows only when the stock offers it.
3. With **Reward** or **Community**, pick a **Tax** of 1% (default) or 3%. A line below sums up the terms, such as "Reward mode: a 1% tax is taken on every transfer and paid out to holders by StonkFun."

The review shows your choice next to the stock, such as "TSLAX · community (3% tax)".

A saved setup can name **Community** for a stock that does not offer it. Then an amber line under **Mode** names the stock. It says the stock "does not offer Community mode — pick Standard or Reward, or another stock." The same line shows in "Before you can launch, add:". Click **Fix** to go back to **Mode**. **Create** and Quick deploy's **Deploy** stay greyed out until you change it.

## pons options

- **Creator fees** — who gets the creator share of each trade: **Creator wallet**, **Holders** or **Custom address** (a 0x address on Robinhood Chain). **Holders** costs two extra transactions from the creator wallet at launch.
- **Tax** — the creator share of each trade. The box shows the highest allowed value as "max".
- **Buyback** — uses the platform's share of fees to buy your token back.

## Dev buy

The [dev buy](https://vortexdeployer.com/docs/other/glossary#dev-buy) is set on the [Wallets step](https://vortexdeployer.com/docs/launch/wallets-step). The limits are 85 SOL, 10 ETH, or 1,000,000 USDC or USD1. **Max** keeps 0.045 SOL per launch for fees and rent.

## Launch at

On **Review & Deploy**. Leave it empty to launch now. Or pick a time from 30 seconds to 30 days ahead.

1. Pick a date and time in **Launch at**. The **Create** button now reads **Schedule**.
2. Click **Schedule**. The wizard closes. You see "Launch scheduled for" with the time and a task number.
3. The draft waits on **Projects** until then. Click **Cancel schedule** on its tile to stop it. The draft stays.

The whole launch, with the dev buy and tasks, runs as one [scheduled launch](https://vortexdeployer.com/docs/other/glossary#scheduled-launch). Click the **×** next to the time (**Mint now instead**) to clear it.

## Launches

**Launches** makes the same token setup up to 10 times in a row. The default is 1. Each launch uses the same wallets, dev buy and tasks.

- With more than 1, the line below checks your wallets, for example "Your wallets fund 3 of 5 launches" and the reason.
- The [launch batch](https://vortexdeployer.com/docs/other/glossary#launch-batch) stops at the first launch your wallets cannot pay for. Earlier launches keep running.
- The terminal opens after the first launch. The rest launch in the background, and you can keep working. A notice counts them, for example "Minted 2 of 5 launches".
- Each new token shows on **Projects** as it lands.
- A custom token address only works with 1 launch.

:::warning Every launch spends again
Each launch in a batch pays its own dev buy, fees and task buys. With 5 launches, every buyer wallet buys 5 times. Check the cost line before you press **Create**.
:::

## Before you can launch

**Review & Deploy** lists anything still missing under "Before you can launch, add:". Click **Fix** to jump to it. **Create** stays greyed out until the list is empty.

:::danger Create is real
There is no test mode in the wizard. **Create** and **Schedule** spend real money and cannot be undone. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## See also

- [Pair tokens](https://vortexdeployer.com/docs/launch/pair-tokens)
- [Scheduled launch](https://vortexdeployer.com/docs/tasks/scheduled-launch)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)
- [After launch](https://vortexdeployer.com/docs/launch/after-launch)

---

# Pair tokens

> Pick the coin your token is priced in and bought with, and see what each choice costs.

Source: https://vortexdeployer.com/docs/launch/pair-tokens · Markdown: https://vortexdeployer.com/docs/launch/pair-tokens.md

A [pair token](https://vortexdeployer.com/docs/other/glossary#pair-token) is the coin your token is priced in and bought with. Most tokens pair with SOL. You pick it on step 1 of the wizard, in the **Quote** row. It cannot be changed after launch.

## Which pairs each launchpad offers

| Launchpad | Pairs |
| --- | --- |
| Pump.fun | SOL, USDC, **Custom pairs** |
| LaunchLab, Bonk, Bonkers | SOL, USD1 |
| StonkFun | a stock only |
| Bags | SOL |
| pons | ETH, USDG, stocks, **Custom CA** |

## SOL

The default and the simplest choice.

- **Pick it when** you want buyers to pay with the coin they already hold.
- **Cost** — no extra swap. The dev buy and all task amounts are in SOL.
- **For buyers** — they buy and sell with SOL.

Only a SOL pair on Pump.fun can use [OTC Desks pairing](https://vortexdeployer.com/docs/launch/otc-desks).

## USDC and USD1

USDC and USD1 are [stablecoins](https://vortexdeployer.com/docs/other/glossary#stablecoin), coins that stay close to one US dollar.

- **Pick it when** you want your token's price to follow dollars, not SOL.
- **Cost** — the creator wallet must already hold the stablecoin for the dev buy. The launch does not swap for it. Use **Convert** on the [Wallets](https://vortexdeployer.com/docs/wallets/overview) page first. That swap has its own small cost.
- **For buyers** — the price is in dollars. In this app, a buy with SOL is swapped through the stablecoin first.

## Custom pairs on Pump.fun

Pick **Custom pairs** in the **Quote** row. A **Pair** row opens. Until you pick, it reads "pick the token the curve is quoted in".

![The pair-token picker after Quote, Custom pairs](https://vortexdeployer.com/docs/launch/pair-tokens.png)

1. Pick a chip in the **Pair** row.
2. Or open **More pairs… (n)**, where n is how many more there are. **Listed** holds the stocks and coins pump.fun accepts as a pair. **Pump coins** holds coins that other launches pair with. Each one ends in "via X", the coin or coins a buy passes through first.
3. Or click **Any pump coin**, paste the address of any coin launched on pump.fun, and click **Use**. The app checks the coin first.

A line under the row sums up your pick. If the list does not load, the row says "pump.fun pairs unavailable" with the reason.

## Stocks on Pump.fun (Custom pairs)

A [tokenized stock](https://vortexdeployer.com/docs/other/glossary#tokenized-stock) from the **Listed** group or the chips.

- **Pick it when** you want your token to trade against a stock.
- **Cost** — you type the dev buy in SOL. The launch swaps it into the stock, then buys your token. The creator wallet only needs SOL. The swap has a small cost.
- **Fees** — you set the **Custom-pair fee (%)**, the [creator fee](https://vortexdeployer.com/docs/other/glossary#creator-fees) every trade pays. From 0.01% to 3%, default 1%. It is final at launch.
- **For buyers** — a buy goes SOL to stock to your token. In this app it can take two transactions. If the second one fails, the wallet keeps the stock, and you can swap it back in the terminal.

## Another pump coin (Custom pairs)

Pick a coin from the **Pump coins** group, or paste one with **Any pump coin**.

- **Pick it when** you want your token tied to another [pump coin](https://vortexdeployer.com/docs/other/glossary#pump-coin).
- **Cost** — amounts are in SOL. The launch, with its dev buy, is one transaction. No wallet needs to hold the pair coin.
- **Fees** — the same **Custom-pair fee (%)** as for stocks. Each trade crosses two or more markets and pays the trading fees of each.
- **For buyers** — they pay SOL. The line under the row shows the buy route, for example "each buy routes SOL → PUMP → your coin in one transaction". Each sell is one transaction too.

A coin can be priced in another pump coin. Then the route has more steps, such as SOL → A → B → your coin. If the line does not end with "in one transaction", the chain starts in another coin, such as USDC. That coin is bought first.

## StonkFun stocks

**StonkFun** has no SOL pair. You must pick a stock before you can launch. Until you do, the **Stock** row reads "pick the stock the curve is quoted in — StonkFun has no SOL quote".

1. Pick a stock chip in the **Stock** row, or open **More stocks… (n)**.
2. Or click **Mint**, paste a stock's address, and click **Use**. Only stocks StonkFun lists work.
3. Wait for "Checking quote availability..." to finish.

A stock that is new to the app may have no SOL route yet. You see a message such as "No SOL route to SPYX yet — finding one now. Retry in a few seconds." The app checks again by itself every 5 seconds, up to 6 times. You can also click the refresh button, **Retry quote check**. If the check still fails, pick another stock.

- **Cost** — you type the dev buy in SOL. The launch swaps it into the stock first. The creator wallet only needs SOL.
- **Mode** — **Standard**, **Reward** or **Community**. Reward and Community add a 1% or 3% tax on every transfer. **Community** shows only when the stock offers it. See [StonkFun options](https://vortexdeployer.com/docs/launch/launch-settings#stonkfun-options).
- **For buyers** — the same as stocks on Pump.fun: SOL is swapped through the stock.

## pons pairs (Robinhood Chain)

On **pons** ([Robinhood Chain](https://vortexdeployer.com/docs/other/glossary#robinhood-chain)), the **Quote** row offers ETH, USDG (the Global Dollar) and stocks, with more under **More stocks…**. **Custom CA** takes any 0x token address pons accepts. Click **Use** to check it.

- **ETH** — the wallets spend their own ETH. Nothing is swapped.
- **USDG, a stock or a custom token** — you type the dev buy in ETH. The launch swaps it into the pair token first. A 1% swap fee comes out of the dev buy. The launch fee and network fees are on top, in ETH.

The line under the picker shows how much of the pair token the [bonding curve](https://vortexdeployer.com/docs/other/glossary#bonding-curve) needs to graduate.

:::warning Every pair spends real money
The dev buy and every task buy spend real money at launch. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Limits with Custom pairs

- **Mayhem** mode is not offered with **Custom pairs**.
- A **Bundle** with a Custom pair fits at most 8 buyers.

## See also

- [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings)
- [Wallets step](https://vortexdeployer.com/docs/launch/wallets-step)
- [OTC Desks pairing](https://vortexdeployer.com/docs/launch/otc-desks)
- [Chains & launchpads](https://vortexdeployer.com/docs/overview/chains-and-launchpads)

---

# Clone a token

> Copy another token's look with Vamp, or copy every new launch of another creator with Copy deploy.

Source: https://vortexdeployer.com/docs/launch/clone-token · Markdown: https://vortexdeployer.com/docs/launch/clone-token.md

There are two ways to copy here. **Vamp** copies the look of one token into your launch form. **Copy deploy** watches another creator and launches a copy of each new token they make.

## Vamp a token

**Vamp** fills your launch form with another token's name, symbol, description, links and image.

![The Vamp window before an address is pasted](https://vortexdeployer.com/docs/launch/clone-token.png)

You find **Vamp** in three places:

- The [Create Project](https://vortexdeployer.com/docs/launch/create-project) wizard, next to **Reuse**.
- The [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy) window, next to **Reuse**.
- The top of the **XID** page. There it opens the wizard with the token's look filled in.

1. Click **Vamp**. The **Vamp a token** window opens.
2. Paste the token's [contract address](https://vortexdeployer.com/docs/other/glossary#contract-address) into **Contract address**. A Solana address or a 0x address both work. The **Paste from clipboard** button next to the box does it for you.
3. Click **Load**. You see the token's image, name and symbol, with its **Description** and its **X**, **Telegram** and **Website** links.
4. Click **Use this look**. The form fills in. Change anything you like before you launch.

The image is copied as your own file. If it cannot be copied, a message asks you to pick an image yourself.

In Quick deploy, Vamp fills only the name, symbol and image. Click **Full wizard** to keep the description and links too.

### Vamp options

- **Auto-detect clipboard** — when the window opens, it takes a token address from your clipboard. On by default.
- **Auto-load** — loads the token as soon as a valid address is in the box. On by default.

Both are remembered in this browser.

:::info What Vamp does not copy
Vamp copies the look only. The launchpad, [pair token](https://vortexdeployer.com/docs/other/glossary#pair-token), wallets, dev buy, fees and tasks are yours to set. Nothing about the old token's price or holders comes along.
:::

## Copy deploy

**Copy deploy** watches another creator's wallet and launches a copy of each new token they make, from your wallet, on its own. Unlike Vamp, it copies the whole launch, not only the look, and every copy spends real SOL or ETH. See [Copy deploy](https://vortexdeployer.com/docs/launch/copy-deploy).

## Troubleshooting

- **"Not a Solana mint (base58) or a 0x contract address."** — check that you pasted the whole token address.

## See also

- [Token details](https://vortexdeployer.com/docs/launch/token-details)
- [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy)
- [Deploy from XID](https://vortexdeployer.com/docs/xid/deploy)

---

# Copy deploy

> Watch another creator's wallet and launch a copy of each new token they make, from your own wallet.

Source: https://vortexdeployer.com/docs/launch/copy-deploy · Markdown: https://vortexdeployer.com/docs/launch/copy-deploy.md

**Copy deploy** watches another creator's wallet for you. Each time that wallet launches a new token, your wallet launches a copy of it right away. The copy has the same name, ticker, picture and launch settings, on the same [launchpad](https://vortexdeployer.com/docs/other/glossary#launchpad). It copies launches on Pump.fun, LaunchLab, Bonk, Bonkers, StonkFun and Meteora launchpads such as Bags, on Solana. On [Robinhood Chain](https://vortexdeployer.com/docs/other/glossary#robinhood-chain) it copies pons launches.

:::warning Every copy is a real launch, with no question first
Each copy spends real SOL or ETH from your deploy wallet: the [dev buy](https://vortexdeployer.com/docs/other/glossary#dev-buy), [rent](https://vortexdeployer.com/docs/other/glossary#rent) and [network fees](https://vortexdeployer.com/docs/other/glossary#network-fee). The app does this on its own, as soon as the creator launches. It can happen up to **Max per hour** times an hour for each watcher, and it keeps going while you are away. [Tasks](https://vortexdeployer.com/docs/other/glossary#task) you add to the copies spend more. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Before you start

- A wallet on the chain you want to copy, with SOL or ETH in it. This wallet makes and pays for every copy.
- The address of the creator wallet you want to watch.
- Optional: a [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy) preset on the same chain. A new watcher takes its dev buy and launch tasks from your active preset.

## Open Copy deploy

- Click your picture or initial at the top right and pick **Copy deploy**.
- Or click the **Copy deploy** button (a copy icon) in the bar at the bottom of the app. The **Copy monitor** opens. Click **Manage watchers** in it.
- On a phone, open the menu and pick **Copy deploy**. **Copy monitor** in the same menu opens the monitor.

![The Copy Deploy page: Watch a creator, Watched creators and Recent activity](https://vortexdeployer.com/docs/launch/copy-deploy.png)

At the top of the page you see **Watching**, **Deployed** and **Duplicates blocked**.

## Watch a creator

1. Under **Watch a creator**, pick the **Chain**: **Solana** or **Robinhood**.
2. Type a **Label (optional)**, such as the creator's name. Up to 80 characters.
3. Paste the address into **Creator wallet to watch**.
4. Pick **Your deploy wallet**. If the list is empty, click **Add a wallet**.
5. Check the launch settings, the duplicate rules and the limits. They are explained below.
6. Click **Start watching**. A question names the creator, your wallet and the hourly limit. Confirm it.
7. You see "Watcher started. New launches will deploy from your wallet." The watcher shows under **Watched creators**.

From now on, every new launch by that wallet is copied. Tokens the creator made before are not. A launch is copied only while it is less than two minutes old.

You can watch up to 20 creators. You can watch each creator once per deploy wallet. You cannot watch your own deploy wallet: a wallet cannot copy its own launches.

## Launch settings

- **Dev buy (SOL)** — what your wallet buys the moment it creates the copy. Leave it blank to buy the same amount the creator bought. Type 0 to skip it. Up to 85 SOL. On Robinhood the box says **Dev buy (ETH)**, up to 10 ETH. If your preset buys with another coin, such as USDC, it says **Dev buy (quote tokens)**.
- **Apply Quick Deploy settings** — loads the dev buy and launch tasks of your active preset again. Each task shows its name, its number of wallets and whether it starts after launch. **Remove** takes one out.
- **Edit preset & tasks ↗** — opens your Quick deploy settings.

The form starts from your active Quick deploy preset when that preset is on the same chain. If not, it starts blank: no tasks, and a blank dev buy. The dev-buy [slippage](https://vortexdeployer.com/docs/other/glossary#slippage) and the priority fee also come from the preset. They are not shown here.

Settings are saved with the watcher. After you change the preset, click **Apply Quick Deploy settings** again.

:::warning A blank dev buy has no limit
A blank **Dev buy** copies the creator's buy, however big it is. If the creator buys 40 SOL, your copy tries to buy 40 SOL. If your wallet cannot pay it, the copy fails. Type an amount if you want a limit.
:::

Your tasks start only after the copy is confirmed on the chain. Tasks set to stay paused stay paused. The creator's own bundles and tasks are never copied.

## Duplicate protection

- **Same name** and **Same ticker** — skip a launch whose name or ticker matches a copy you already made. Both are on by default. Letter case and spaces do not count. Either match blocks the copy.
- **Check previous copies** — where to look for a match: **Across my watchers on this chain** (the default) or **Only this creator on this chain**.

## Limits

- **Cooldown (sec)** — the least time between two copies from this watcher. Default 30, from 0 to 86,400 (one day).
- **Max per hour** — the most copies this watcher starts in one hour. Default 5, from 1 to 100. Failed copies count too.

## What a copy keeps

- The name, ticker, picture, launchpad and launch settings of the original.
- Its [creator fees](https://vortexdeployer.com/docs/other/glossary#creator-fees) setup. Fees that went to the original creator go to your wallet. If the original sends its fees to another address, or shares them, your copy does the same.
- Nothing else. Other wallets' buys in the same launch, later trades and later changes by the creator are not copied.

## Manage your watchers

**Watched creators** lists your watchers, with a count such as 3/20. A green dot means the watcher is on. A grey dot means it is paused. Each row shows the hourly limit, the cooldown and the duplicate rules.

- **Pause or resume** — press the pause button on the row. Press the play button to resume. Launches made while a watcher is paused are never copied later.
- **Change settings** — press the gear button. Change the launch settings, **Duplicate protection**, **Cooldown (sec)** or **Max per hour**. Then click **Save settings**.
- The chain, the creator, the deploy wallet and the label cannot be changed. Start a new watcher instead.
- You cannot delete a watcher. Pause it instead. Paused watchers still count toward the 20.

:::info Simulation watchers
Watchers you start on this page are always live. A watcher made in the past, when the app still had a test mode, may carry a **Simulation** tag. It only tests each copy and spends nothing. Its copies show as **Simulation passed**. Press **Go live** and confirm to make it copy for real. You cannot switch a live watcher back.
:::

## Recent activity

**Recent activity** lists the last 100 copy attempts. Filter it by **All**, **Live** or **Blocked**. Each row shows a status:

- **Queued** or **Deploying** — the copy is waiting or on its way.
- **Deployed** — the copy launched. **Open copy** opens it in the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal).
- **Skipped** — no copy was sent. The reason is under the row, such as "Watcher cooldown".
- **Duplicate blocked** — the launch matched an earlier copy.
- **Failed** — the copy did not launch. The reason is under the row. A failed copy is not tried again.
- **Needs review** — the app cannot tell if the copy landed. Check your deploy wallet on an [explorer](https://vortexdeployer.com/docs/other/glossary#explorer) before you do anything else.

**Trading P&L** above the list sums your trades in the copies and what you still hold. It leaves out launch costs and creator fees.

The **Copy monitor** is a small window with the same list, on any page. Drag it to move it, and drag its corner to resize it. Open it with **Open monitor** at the top of this page, or with the **Copy deploy** button in the bottom bar.

## Troubleshooting

- **A copy failed with 'Copy creation simulation failed: "AccountNotFound"'** — your deploy wallet has no SOL. Add SOL to it. Nothing was spent. The same reason can also read 'Copy simulation failed: "AccountNotFound"'.
- **A creator launched but nothing was copied** — check **Recent activity**. A **Skipped** row gives the reason, such as "Watcher cooldown", "Hourly deploy limit reached" or "Source launch is over two minutes old; no late copy was sent". **Duplicate blocked** means a duplicate rule matched. No row at all means the watcher was paused or started after that launch. Or the launch was on a launchpad Copy deploy does not copy.
- **No wallet to pick in Your deploy wallet** — the chain has no wallet yet. Click **Add a wallet**.
- **"Quick Deploy dev-buy currency does not match this launch…"** — your dev buy is priced in another coin than the creator's launch. Clear **Dev buy** to copy the creator's buy, or pick a preset with a matching [pair token](https://vortexdeployer.com/docs/other/glossary#pair-token).

## See also

- [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy)
- [Clone a token](https://vortexdeployer.com/docs/launch/clone-token)
- [Fund wallets](https://vortexdeployer.com/docs/wallets/fund)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)

---

# OTC Desks pairing

> Pair a Pump.fun launch with OTC Desks so its creator fees pay your holders a reward.

Source: https://vortexdeployer.com/docs/launch/otc-desks · Markdown: https://vortexdeployer.com/docs/launch/otc-desks.md

[OTC Desks](https://vortexdeployer.com/docs/other/glossary#otc-desks) is a separate site, otcdesks.cash. When you pair a token with it, the token's [creator fees](https://vortexdeployer.com/docs/other/glossary#creator-fees) go to OTC Desks instead of your wallet. OTC Desks uses them to pay your holders a reward, such as a [tokenized stock](https://vortexdeployer.com/docs/other/glossary#tokenized-stock).

:::danger The pairing is permanent
Once the token launches, all of its creator fees go to OTC Desks for good. You cannot point them back to your own wallet.
:::

## Before you start

The **OTC Desks** row shows only when all of these are true:

- The launchpad is **Pump.fun**.
- The **Quote** is **SOL**. See [Pair tokens](https://vortexdeployer.com/docs/launch/pair-tokens).
- **Fees** is set to **Creator Fees**. **Holder Rewards** cannot be paired.

## Turn it on

You find the row under **Fees** on step 1 of the wizard, in the [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy) window, and in **Settings** → **Quick deploy**.

![OTC Desks set to Paired, with the desk picker](https://vortexdeployer.com/docs/launch/otc-desks.png)

1. Set **OTC Desks** to **Paired**. The default is **Off**.
2. Under **Reward**, pick **Single** for one reward, or **Basket (2–5)** for two to five.
3. Click a reward chip, or find more under **More rewards…**.
4. Or click **Mint**, paste the address of any Solana token, and click **Use**. It is added to the OTC Desks community list first. If OTC Desks refuses it, you see why right away.

Community tokens and rewards that are not listed yet work only as a **Single** reward.

The line below starts with "Holders earn". It names your reward and shows how OTC Desks splits the creator fees between holders and its own uses.

## Limits

OTC Desks takes an **X** link of at most 120 characters. With a longer one, the app refuses the paired launch before anything is sent. The name, symbol and description limits of [Token details](https://vortexdeployer.com/docs/launch/token-details) already fit OTC Desks.

The app also refuses a paired launch while otcdesks.cash is not answering. Try again in a few minutes, or launch without pairing. This check applies when you press **Create**, **Schedule** or **Deploy**. A launch that is already scheduled, and the later launches of a batch, go ahead without it.

## What happens at launch

1. If you left **Website** empty, the token's OTC Desks page becomes its website. A website you typed is kept.
2. The token launches like any Pump.fun launch, with its dev buy and tasks.
3. Right after, the [creator wallet](https://vortexdeployer.com/docs/other/glossary#creator-wallet) sends one more transaction. It routes the creator fees to OTC Desks.
4. The token registers on OTC Desks. Its page shows up there within about a minute.

:::warning Keep a little SOL in the creator wallet
The pairing transaction pays a small network fee and rent from the creator wallet. Without enough SOL it fails.
:::

## Check the pairing

The project's tile on **Projects** has an **OTC Desks** line:

- **Pairing…** — the pairing has started.
- **Fees routed · registering…** — fees go to OTC Desks. The token is being listed.
- **Paired** — done. The line turns into a link to the token's OTC Desks page.
- **Pairing failed** — hover the line to see why.

The launch result shows the same state. A failed pairing never stops the token itself. It trades as normal, but it is not listed on OTC Desks:

- If the fee transaction failed, the fees still go to your creator wallet.
- If the fee transaction landed and only the listing failed, the fees already go to OTC Desks.

## Troubleshooting

- **The OTC Desks row is missing** — check that you picked **Pump.fun**, a **SOL** quote and **Creator Fees**.
- **"OTC Desks limits the X link to 120 characters"** — shorten the **X** link.
- **"otcdesks.cash is not answering right now"** — wait a few minutes, then press **Create** again.

## See also

- [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings)
- [Pair tokens](https://vortexdeployer.com/docs/launch/pair-tokens)
- [After launch](https://vortexdeployer.com/docs/launch/after-launch)

---

# After launch

> What you see after you press Create or Deploy, how to read the result, and what to do next.

Source: https://vortexdeployer.com/docs/launch/after-launch · Markdown: https://vortexdeployer.com/docs/launch/after-launch.md

When you press **Create** in the wizard or **Deploy** in Quick deploy, the launch is sent. The window closes and the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal) opens on your new token.

## The first seconds

1. The terminal shows **Preparing** and your symbol, for example **Preparing CAT**, until the token's address is known.
2. Then it switches to your token. Prices, trades and holders fill in as the launch and the first buys land.
3. A message tells you the result. See the list below.

With more than one launch, the terminal opens after the first one. The rest launch in the background. See [Launch settings](https://vortexdeployer.com/docs/launch/launch-settings).

## Read the result

- **Token minted!** — the token exists. Your tasks are starting.
- **Minted — but N task(s) failed to start** — the token exists, but some tasks did not start. Open the **Tasks** panel to see which ones and why.
- **Mint failed:** and a reason — the token was not made.
- **Launch confirmation pending. Do not launch again while this transaction is being checked.** — wait. The app is still checking whether the launch landed.

If the launch could not start at all, the terminal shows **Launch could not start** with the reason, and a **View projects** button. If you reloaded the page before the result came in, it shows **Check launch status**. Open **Projects** to see what happened before you try again.

:::danger Do not launch twice
A launch that looks stuck may still land. Check **Projects** first. A second **Create** makes a second token and spends the money again. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

Creator-fee or [OTC Desks](https://vortexdeployer.com/docs/launch/otc-desks) messages can arrive after the token itself launched. They do not mean the launch failed.

## Your project on Projects

Every launch gets a tile on **Projects**. Its status line shows where the token is:

- **Launching** — the launch was sent and is being checked.
- **Bonding** — the token trades on its [bonding curve](https://vortexdeployer.com/docs/other/glossary#bonding-curve).
- **Graduated** — the curve filled and the token moved to its own pool. See [graduation](https://vortexdeployer.com/docs/other/glossary#graduation).
- **No live pool** — no market prices the token right now.

When tasks run, the line adds "· N tasks running". The tile also shows **P&L**, **Market cap**, **Liquidity** and **Bag**, the value of what your wallets still hold.

The tile's menu has **Open terminal**, **Project wallets** and **Copy mint address**.

## In the terminal

- **Tasks** — every task of this token, one per line. Switch the list between **Active** and **All**. Open a task to pause or stop it.
- **New task** — add a task on this token, such as Volume, a sell Ladder or Anti-Sniper. See [How tasks run](https://vortexdeployer.com/docs/tasks/overview).
- The tabs below the chart: **Wallets**, **Trades**, **Holders**, **Bubblemaps**, **Pools** and **History**.
- **Share PnL** — makes a picture of your result to share. See [P&L share cards](https://vortexdeployer.com/docs/terminal/pnl-cards).
- The fee button in the **Position** panel — what your token earns from trading. See below.

![A launched token in its terminal](https://vortexdeployer.com/docs/launch/after-launch.png)

:::warning Tasks trade with real money
Every task you start from the terminal buys and sells with real SOL or ETH, and pays the platform fee. See [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees).
:::

## Claim creator fees

Trades of your token can pay [creator fees](https://vortexdeployer.com/docs/other/glossary#creator-fees). The fee button in the **Position** panel shows them. Its label depends on the token:

- **Claim fees** — your own Solana launch. It opens the claim window.
- **Fee details** — another Solana token. Only its creator can claim, so the window has nothing to claim for you.
- **Holder Rewards** — pump.fun pays the fees to holders by itself. There is nothing to claim.
- **Creator fees** — Robinhood Chain. The fees go to the creator wallet by themselves. The window shows the totals.

To claim on Solana:

1. Open your token from **Projects** and click **Claim fees**.
2. Check the list. Each line is one place that holds fees for you, with the amount waiting.
3. Click **Claim all**. One transaction claims every line, signed by the [creator wallet](https://vortexdeployer.com/docs/other/glossary#creator-wallet).

The fees land in the creator wallet. Fees paid in wrapped SOL arrive as plain SOL.

- Only the creator wallet of your own launch can claim. It must be a wallet you have in the app.
- A line needs at least 0.001 SOL waiting. Smaller amounts stay until they grow.
- A line you claimed less than a minute ago shows "Claimed under a minute ago". **Claim all** skips it.
- The creator wallet pays the network fee. It may also pay rent for a token account the fees land in. If it holds too little, nothing is sent and the message says how much to add.

## When you are done

- [Collect funds](https://vortexdeployer.com/docs/wallets/collect) to bring SOL or ETH back to one wallet.
- Or use [Close out](https://vortexdeployer.com/docs/launch/close-out) on **Projects**. It sells what is left, closes empty accounts and collects the SOL, for several projects at once.

## Troubleshooting

- **A task did not start** — open it in the **Tasks** panel. Its card says why.
- **The tile says No live pool** — the app finds no live market for the token. Open the **Pools** tab in the terminal to check.
- **A batch stopped early** — the wallets could not pay for the next launch. The tokens made before it stay live.

## See also

- [The terminal](https://vortexdeployer.com/docs/terminal/overview)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Close out](https://vortexdeployer.com/docs/launch/close-out)
- [Collect funds](https://vortexdeployer.com/docs/wallets/collect)

---

# Close out

> Sell what is left of finished launches, get back the rent and collect the SOL or ETH, for several projects at once.

Source: https://vortexdeployer.com/docs/launch/close-out · Markdown: https://vortexdeployer.com/docs/launch/close-out.md

A finished launch leaves tokens in many wallets, empty token accounts that hold [rent](https://vortexdeployer.com/docs/other/glossary#rent), and SOL or ETH spread over the project wallets. **Close out** cleans all of this up in one run, for as many projects as you pick.

:::danger Close out sells everything
Every wallet sells its whole bag for whatever the market pays at that moment. The sells cannot be undone. Use it only on launches you are done with. There is no test run. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## What it does

For each project you pick:

1. **Sells every bag.** Every wallet that holds the token sells all of it, at the same time.
2. **Closes empty token accounts** (Solana only). Their rent goes to your destination wallet.
3. **Collects the coin.** A [Collect funds](https://vortexdeployer.com/docs/wallets/collect) task sends the project wallets' SOL or ETH to your destination wallet.

Projects run one after another.

## Close out projects

1. Open **Projects** and click **Close out**. The button shows once you have a launched project. The **Close out projects** window opens.
2. Pick the **Chain**. One run covers one chain.
3. Tick the projects you are done with, or click **Select all**. **Clear** unticks them. Use **Find project** to search. Each row shows its stage, such as **Bonding** or **Graduated**.
4. Check the **Destination wallet**. Everything goes there. It starts on the creator wallet of your newest launch.
5. Click **Close out N projects**.
6. Read the confirm window. It says what will sell, close and move, and to which wallet. Click **Sell, close and sweep** to start, or **Back** to change something.

![The Close out projects window](https://vortexdeployer.com/docs/launch/close-out.png)

:::warning The sweep keeps running
The collect step runs as a task. To stop it, open the run's **Operation details** window from its notification, click **Follow sweep task #N**, and stop the task there. See [Operation progress](https://vortexdeployer.com/docs/account/operations).
:::

## Watch the progress

The window turns into a list, one line per project. Open a line to see what sold, which accounts closed, any errors per wallet, and the receipts.

- **Run in background** — hides the window while the run goes on. The **Closeout** chip at the bottom of the app brings it back.
- **Stop remaining** — stops the projects that have not started yet.
- **Paused for review** — a project needs a look. Open its line to see why. **Continue remaining** then starts only the waiting projects. Steps already done are kept.
- **Done** — closes the window when the run is over.

The run is saved to your account. If you close the window or the tab, open **Close out** again and click **Resume closeout**. You also get [notifications](https://vortexdeployer.com/docs/account/notifications) that open the run on [Operations](https://vortexdeployer.com/docs/account/operations).

## Troubleshooting

- **No Close out button** — you have no launched project yet.
- **A wallet kept its tokens** — open the project's line. It names the wallet and the error. You can sell what is left from the terminal.
- **Accounts did not close on Robinhood Chain** — that is expected. Only Solana has token accounts to close.

## See also

- [Collect funds](https://vortexdeployer.com/docs/wallets/collect)
- [After launch](https://vortexdeployer.com/docs/launch/after-launch)
- [Operation progress](https://vortexdeployer.com/docs/account/operations)

---

# CTO an existing token

> Take over a token you did not launch here and trade it with your own wallets.

Source: https://vortexdeployer.com/docs/launch/cto · Markdown: https://vortexdeployer.com/docs/launch/cto.md

**CTO** lets you manage a token that already exists, made somewhere else or by someone else, with your own wallets. CTO means "community takeover". It makes a [project](https://vortexdeployer.com/docs/other/glossary#project) for that token, so you get the terminal, tasks and P&L, just like for your own launch.

## Before you start

- You need the token's [contract address](https://vortexdeployer.com/docs/other/glossary#contract-address).
- CTO does not launch anything. It costs nothing until you fund wallets or start trades.

## Open CTO

- On a wide screen, click **CTO** at the top of the app.
- On a smaller screen, open **Projects** and click **CTO**.
- On a phone, open the menu and tap **CTO**.

## Step 1: Token mint

1. Paste the token's address into **Mint address**.
2. Click **Next: Wallet setup**. The button shows "Finding token…" while it looks.

![The CTO window on its first step](https://vortexdeployer.com/docs/launch/cto.png)

The app finds the token and makes the project. The chain comes from the address.

## Step 2: Wallet setup

1. Add the wallets that will trade the token. Use the tiles at the top:
   - **Create** — make new wallets.
   - **Import** — paste private keys.
   - **Global** — add wallets from your [wallet pool](https://vortexdeployer.com/docs/other/glossary#wallet-pool).
2. Click **Fund** to send SOL or ETH to them. See [Fund wallets](https://vortexdeployer.com/docs/wallets/fund).
3. Click **Open Swap Manager**. You need at least one wallet first.

There is no creator wallet to pick, because you did not make this token. The tiles work as on the [Wallets step](https://vortexdeployer.com/docs/launch/wallets-step).

The terminal opens on the token with your wallets attached. From there, add tasks with **New task**, or trade by hand in the [Trade panel](https://vortexdeployer.com/docs/terminal/trade-panel).

:::warning Trades are real
CTO itself spends nothing. But every buy, sell and task after it uses real SOL or ETH, and pays the platform fee. See [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees) and [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Troubleshooting

- **"Add at least one wallet to continue."** — add a wallet with one of the tiles before you click **Open Swap Manager**.
- **The token is not found** — check that you pasted the full address, on the chain you expect.

## See also

- [The terminal](https://vortexdeployer.com/docs/terminal/overview)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Wallets step](https://vortexdeployer.com/docs/launch/wallets-step)

---

# The terminal

> One screen for each token, with its chart, live trades, your wallets and the Trade panel.

Source: https://vortexdeployer.com/docs/terminal/overview · Markdown: https://vortexdeployer.com/docs/terminal/overview.md

The [terminal](https://vortexdeployer.com/docs/other/glossary#terminal) is where you watch and trade one token. It shows the chart, live trades, your wallets, your position and the tasks running on that token.

![A token in the terminal, Terminal layout](https://vortexdeployer.com/docs/terminal/overview.png)

:::warning Every press is a real trade
The terminal has no practice mode. Every buy and sell button spends real SOL or ETH right away, pays the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee) and cannot be undone. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Open the terminal

- After a launch, the terminal opens by itself on the new token.
- On **Projects**, press **Open terminal** on a project.
- On a computer, click a token icon in the bar on the left.
- In the user menu, choose **Swap**. It opens your newest launch.

To open any other token, click the token image at the top left. Search your tokens, or paste a [contract address](https://vortexdeployer.com/docs/other/glossary#contract-address).

## The header

The top row shows the token's name and chain. Buttons copy the contract address or open the explorer. Under it you see **Price**, **Market cap**, **24h volume**, **Liquidity** and **Supply**. **Buys**, **Sells** and **Net flow** cover the last 24 hours.

At the top right sit the layout switch and **Share PnL**. See [P&L share cards](https://vortexdeployer.com/docs/terminal/pnl-cards).

## Pick a layout

On a computer, two buttons at the top right switch the layout:

- **Terminal** — the default. The chart with the Trades panel beside it and your wallet tabs below. A right column holds the Trade panel, your position and your tasks.
- **Side by side** — the chart over the Trades panel on the left. On the right: your position, the wallet tabs, then the Trade panel beside your tasks.

![The Side by side layout](https://vortexdeployer.com/docs/terminal/side-by-side.png)

The app remembers your layout, and the chart height for each layout.

:::tip Resize the panels
Drag the line between the chart and the Trades panel to make one wider. Double-click it to reset. Drag the chart's bottom edge to change its height. Double-click that edge to fold the chart away.
:::

![Switching between the Terminal and Side by side layouts, and Trades between SOL and USD](https://vortexdeployer.com/docs/terminal/overview.mp4)

## The chart

The chart shows the token's price over time. Lines mark your wallets' **Avg. Entry** and **Avg. Exit**. A **Migration** line marks the market cap where the token will [migrate](https://vortexdeployer.com/docs/other/glossary#migration). Tasks with price limits draw their limits too. Dev buys and sells show as **DB** and **DS** marks. Wallets you follow in the [KOL tracker](https://vortexdeployer.com/docs/terminal/kol-tracker) show as emoji marks.

## The Trades panel

The **Trades** panel lists every buy (green) and sell (red) as it happens. Each row shows the amount, the market cap, the trader and the age. Click the age to open the transaction. Your own wallets carry a **YOU** tag.

A dot shows **Live** while trades come in, or **Connecting** while the panel reconnects. The switch in the panel's head shows amounts in the coin (SOL, ETH or the pair token) or in **USD**. On a narrow screen, the trades move into the **Trades** tab.

## The right column

- **Trade** — buy or sell with many wallets at once. See [Trade panel](https://vortexdeployer.com/docs/terminal/trade-panel).
- **Position** — your wallets' **Bought**, **Sold**, **Holding** and **PnL** on this token. A button in its head shows the token's fees, such as **Claim fees** or **Creator fees**.
- **Tasks** — the [tasks](https://vortexdeployer.com/docs/other/glossary#task) on this token. Choose **Active** or **All**. Press **New task** to add one. The flame button warms up wallets. See [Tasks](https://vortexdeployer.com/docs/tasks/overview).

## The tabs

- **Wallets** — your [attached wallets](https://vortexdeployer.com/docs/other/glossary#attached-wallet), 100 to a page. Each row shows the balance, bought and sold, P&L and tokens left, with its own buy and sell buttons. **Add wallets** attaches more wallets to your own launches. **Sell all**, **Sell all (excl dev)** and **Sell dev** sit here too. See [Sell all](https://vortexdeployer.com/docs/terminal/sell-all).
- **Trades** — the full list of trades on this token.
- **Holders** — who holds the token: the dev, your wallets, the top 10, other wallets and the pool.
- **Bubblemaps** — a map of holders that seem linked, made by Bubblemaps.
- **Pools** — the markets where the token trades.
- **History** — trades by your attached wallets on this token.

:::danger Burn and Lock are permanent
In a wallet's row, **Burn** destroys that wallet's tokens for good. **Lock** (Solana only) locks them until a date you pick. You cannot end a lock early. Both ask before they send. See [Burn & lock](https://vortexdeployer.com/docs/terminal/burn-and-lock).
:::

## On a phone

The parts stack in one column: chart, Trade panel, position, wallet tabs, tasks, then trades. When the Trade panel scrolls out of view, a **Trade** button brings it back. The **Tasks** button in the wallet tabs jumps to your tasks.

![The terminal on a phone](https://vortexdeployer.com/docs/terminal/overview-phone.png)

## See also

- [Trade panel](https://vortexdeployer.com/docs/terminal/trade-panel)
- [Sell all](https://vortexdeployer.com/docs/terminal/sell-all)
- [P&L share cards](https://vortexdeployer.com/docs/terminal/pnl-cards)
- [KOL tracker](https://vortexdeployer.com/docs/terminal/kol-tracker)

---

# Trade panel

> Buy or sell a token with many of your wallets at once, by amount or by percent.

Source: https://vortexdeployer.com/docs/terminal/trade-panel · Markdown: https://vortexdeployer.com/docs/terminal/trade-panel.md

The **Trade** panel buys or sells the token with every wallet you tick, in one press. It sits at the top of the right column in the [terminal](https://vortexdeployer.com/docs/terminal/overview).

:::warning Each press spends real money
A chip or button sends real trades at once, one per wallet. Buys spend SOL (ETH on Robinhood). Every trade pays the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee) and a [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee). A trade cannot be undone. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Before you start

Attach wallets with **Add wallets** in the **Wallets** tab, and [fund them](https://vortexdeployer.com/docs/wallets/fund) with SOL or ETH.

## Make a trade

1. Press the wallet button in the panel's head (**Select wallets** or **N wallets**). Tick the wallets that should trade.
2. Press the mode button to choose coin amounts (it shows **SOL**, **ETH** or the pair token) or **%**.
3. Choose **Buy** or **Sell**.
4. Press a chip to trade that amount at once. Or type an amount and press **Buy** or **Sell** (or Enter).
5. Read the message that sums up the result, such as "Bought on 3/5 wallets · 2 insufficient balance".

![The Trade panel](https://vortexdeployer.com/docs/terminal/trade-panel.png)

Amounts are per wallet. With 5 wallets ticked, the 0.1 chip buys 0.5 SOL in total.

Buttons never lock. A small number on one counts its trades still running.

## Choose wallets

When the terminal opens, the panel ticks the wallets that hold the token, or all attached wallets if none do. The [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet) is always at the top.

- The menu at the top of the list ticks a set at once, such as **Select all**, **With SOL balance**, **Holding tokens** or a [wallet role](https://vortexdeployer.com/docs/other/glossary#wallet-role). **Deselect all** clears the ticks.
- **Search** — press the magnifier and type in **Search wallets…**.
- **Pick** — choose **Random**, **Low tokens** or **High tokens**, type how many, then press **Pick**.

## Buy

- **Chips** — your buy amounts, per wallet. The defaults are 0.01, 0.05, 0.1, 0.5 and 1 SOL. In **%** mode, each chip is a share of each wallet's spendable balance.
- **MAX** — each wallet spends all it can. It keeps back 0.01 SOL (0.0005 ETH on Robinhood) plus the platform fee.

**MAX** and % buys only work when the token trades against SOL or ETH. On a token paired with another token, use a coin amount.

## Sell

![Switching the Trade panel between Buy and Sell. No trade is sent.](https://vortexdeployer.com/docs/terminal/trade-panel.mp4)

In **%** mode, a switch above the chips picks the base.

- **% of bag** — each wallet sells that share of its own [bag](https://vortexdeployer.com/docs/other/glossary#bag). The defaults are 25, 50, 75 and 100.
- **% of supply** — each wallet sells that share of the token's total supply, but never more than it holds. The chips are 0.1, 0.25, 0.5 and 1.

In coin mode the box reads **Worth**. Each wallet sells tokens worth that much SOL or ETH.

A wallet with no tokens is skipped, not counted as failed. To sell everything at once, see [Sell all](https://vortexdeployer.com/docs/terminal/sell-all).

## Presets and slippage

Your chips come from a [preset](https://vortexdeployer.com/docs/other/glossary#preset): **PRESET 1**, **PRESET 2** or **PRESET 3**. Presets are saved to your account.

- The pencil in the panel's head opens **Edit Quick Actions**. Change the chips, use **Add** (up to 6) or **Reset**, then press **Save presets**.
- The line under the panel shows the [slippage](https://vortexdeployer.com/docs/other/glossary#slippage) and the active preset. Its link opens **Settings → Trading**, where you switch presets and change slippage. The default slippage is 3%.

## Randomize

**Randomize** in **Settings → Trading** is off by default. Turn it on and set how far each buy may go down and up (0–90%). Each wallet then buys a slightly different amount. Sells never change.

:::tip Randomize and MAX
In this panel, Randomize also changes % and **MAX** buys. A **MAX** buy can then ask for more than a wallet has. Set the up band to 0 before you use **MAX**.
:::

## Buttons on each wallet

In the **Wallets** tab, each row has buttons that trade for that one wallet.

- The **Buy** / **Sell** switch in the column head picks which buttons show. It starts on **Sell**.
- Buy buttons are your buy amounts (shares of the balance in **%** mode) and **MAX**. Sell buttons are % of that wallet's bag.
- The wrench in the column head edits these buttons.
- Here, **MAX** and % amounts stay exact, even with Randomize on.

Want a question before trading with a dev-role wallet? Turn on **Confirm dev trades** in **Settings → Trading → Confirmations**. It is off by default.

## Troubleshooting

- **"No buy route for this token yet"** — the app can't find a market to buy through yet. Wait a few seconds and press again.
- **"insufficient balance"** — those wallets lack SOL or ETH for the amount plus fees. Fund them or pick a smaller amount.

## See also

- [Sell all](https://vortexdeployer.com/docs/terminal/sell-all)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)
- [Settings](https://vortexdeployer.com/docs/account/settings)

---

# Sell all

> Sell every token your wallets hold on this token with one press, with or without the dev wallet.

Source: https://vortexdeployer.com/docs/terminal/sell-all · Markdown: https://vortexdeployer.com/docs/terminal/sell-all.md

Three buttons sell whole bags at once. They sit in the **Wallets** tab of the [terminal](https://vortexdeployer.com/docs/terminal/overview), right of **Add wallets**.

- **Sell all** — sells 100% from every attached wallet.
- **Sell all (excl dev)** — the same, but leaves the [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet) alone.
- **Sell dev** — sells 100% from the dev wallet only.

![Sell all, Sell all (excl dev) and Sell dev on the Wallets tab bar](https://vortexdeployer.com/docs/terminal/sell-all.png)

Here "dev" means the wallet that created this token. It is not every wallet with the dev role.

:::warning This sells for real, right away
One press sells for real at market price. It cannot be undone. Each sell pays the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee) on what it gets back, plus a [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee). By default there is no question first. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## What happens when you press

1. The app sends one 100% sell for every wallet in scope. It sends them all at once, not one after another.
2. The server checks each wallet's real balance at that moment. It sells what the wallet really holds, not what the screen showed.
3. A wallet with nothing to sell is skipped. Skips are not failures.
4. When the sells finish, one message sums them up. For example: "Sold on 21/21 wallets · 65 skipped: nothing to sell".
5. Your position, the wallet rows and the Trades panel update as the sells land.

The sells use the [slippage](https://vortexdeployer.com/docs/other/glossary#slippage) of your active preset. A wallet that fails, for example because the price moved too far, is listed in the message. It does not stop the other wallets.

## With many wallets

The buttons send every attached wallet, even ones the screen shows as empty. With 80 wallets attached and 20 holding, you see 20 sold and 60 skipped.

All the sells hit the same market at the same moment. On a small market, each sell pushes the price down for the next one. The last sells can get much less than the first.

:::tip A gentler exit
To sell over time instead, use a [Ladder](https://vortexdeployer.com/docs/tasks/ladder) or a [DCA](https://vortexdeployer.com/docs/tasks/dca) task. To sell part of each bag, use **% of bag** in the [Trade panel](https://vortexdeployer.com/docs/terminal/trade-panel).
:::

The buttons never lock. A small number on a button counts its sells still running. Pressing again sends another round.

## Ask before selling

To get a question before these buttons sell, open **Settings → Trading → Confirmations** and turn on **Confirm Sell all**. It covers all three buttons.

## Sell through another wallet

Under [Settings](https://vortexdeployer.com/docs/account/settings) → **Trading**, **Sell through another wallet** can run each sale from a temporary wallet. Choose **All sells**, or choose **Custom** and turn on **Sell all**, **Sell all except dev** and **Sell dev** one by one.

On Solana this takes two transactions. The first sends 0.01 SOL and the tokens to the temporary wallet. The second sells and sends all the SOL back. Each one pays a network fee. If the temporary wallet can't be set up, the app sells straight from your wallet instead.

## Troubleshooting

- **"No wallets attached"** — this token has no wallets yet. Use **Add wallets** first.
- **"No non-dev wallets attached"** — only the dev wallet is attached, so **Sell all (excl dev)** has nothing to send.
- **"Creator wallet is not available yet"** — the app can't find this token's dev wallet among your wallets. **Sell dev** works only on your own launches, with the dev wallet attached.

## See also

- [Trade panel](https://vortexdeployer.com/docs/terminal/trade-panel)
- [Anti-Sniper](https://vortexdeployer.com/docs/tasks/anti-sniper)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)

---

# Burn & lock

> Destroy a wallet's tokens for good, or lock them until a date you pick, from the terminal.

Source: https://vortexdeployer.com/docs/terminal/burn-and-lock · Markdown: https://vortexdeployer.com/docs/terminal/burn-and-lock.md

Each wallet row in the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal) has buttons for the tokens it holds. **Burn** destroys them. **Lock** puts them in a [Streamflow](https://vortexdeployer.com/docs/other/glossary#streamflow) lock until a date you pick. Teams use them to show that these tokens will not be sold.

:::danger Burn cannot be undone
A [burn](https://vortexdeployer.com/docs/other/glossary#burn) destroys the tokens forever. Nobody can bring them back, not you and not us. A [lock](https://vortexdeployer.com/docs/other/glossary#lock) cannot be opened early either, not even by you. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Before you start

- Open the token in the terminal. See [The terminal](https://vortexdeployer.com/docs/terminal/overview).
- The wallet must hold some of the token. If it holds none, the buttons are greyed out.
- A burn needs a little SOL or ETH for the [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee).
- A lock needs at least 0.01 SOL in the wallet.

## Find the buttons

1. Open the **Wallets** tab.
2. Find the wallet's row. At its right end, under **Ops**, sit two small buttons.
3. The flame button is **Burn**. The lock button is **Lock**. Hover over one to see its name. The lock button shows on Solana only.

![The Burn (flame) and Lock buttons at the end of each wallet row, greyed out on wallets that hold none](https://vortexdeployer.com/docs/terminal/burn-and-lock.png)

## Burn tokens

1. Press the flame button on the wallet's row. The **Burn** window opens with the token's symbol, such as **Burn ABC**.
2. Choose how much:
   - **Percentage of the holding** — 25%, 50%, 75% or 100% of what this wallet holds. 100% is picked at first.
   - **Or an exact amount (ABC)** — type a number of tokens. It can be at most what the wallet holds.
3. Check **Will burn** and **From** on the right.
4. Click **Burn now**. A question asks "Really burn … ? Burning is permanent." Confirm it.
5. When it is done, you see "Burned" with the amount and a short part of the [transaction](https://vortexdeployer.com/docs/other/glossary#transaction) id.

Click **Cancel** to close the window without burning.

:::info Burn works a bit differently on each chain
On Solana, the tokens are destroyed and the token's [supply](https://vortexdeployer.com/docs/other/glossary#supply) goes down. The wallet's empty [token account](https://vortexdeployer.com/docs/other/glossary#token-account) stays open. [Close out](https://vortexdeployer.com/docs/launch/close-out) can close it and give you its rent back.

On Robinhood Chain, the tokens are sent to the [dead address](https://vortexdeployer.com/docs/other/glossary#dead-address). No one controls it, so the tokens can never move again. The total supply number on the chain stays the same.
:::

## Lock tokens

Locks work on Solana only.

1. Press the lock button on the wallet's row. The **Lock** window opens, such as **Lock ABC**. It says "Streamflow hard lock · Solana only".
2. Choose how much: **Percentage of the holding** or **Or an exact amount (ABC)**, as for a burn.
3. Set **Lock duration (days)**. The default is 180 days. You can pick from 1 hour (0.042 days) to 3650 days, about 10 years. The date it unlocks shows under the box.
4. Optional: type a **Lock name (optional)**, such as "Team tokens". Up to 64 characters. If you leave it empty, the lock is named "Token Lock".
5. Check **Will lock**, **Until** and **From** on the right.
6. Click **Lock now**. A question asks "Really lock … until …? The lock cannot be cancelled or moved early." Confirm it.
7. When it is done, you see "Locked" with the amount, the unlock date and a short part of the transaction id.

### How the lock works

- The tokens leave your wallet and sit in a lock on Streamflow until the date.
- Nobody can cancel the lock, add to it or move it to another wallet. Not even you.
- On the unlock date, the whole amount is free to take back. It goes back to the same wallet.
- The app has no button to take tokens out of a lock. After the date, you take them out on Streamflow's own site, with the same wallet. To use the wallet there, you need its [private key](https://vortexdeployer.com/docs/other/glossary#private-key). See [Export a private key](https://vortexdeployer.com/docs/wallets/key-export).
- The app does not list your locks. Write down the unlock date, or look the wallet up on an [explorer](https://vortexdeployer.com/docs/other/glossary#explorer).

## What it costs

- **Burn** — only the network fee. On Robinhood Chain that is a little ETH for [gas](https://vortexdeployer.com/docs/other/glossary#gas). There is no [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee).
- **Lock** — Streamflow takes a fee of about 1%, in the token, on top of the amount you lock. That is why 100% locks a little less than the whole balance. If an exact amount leaves no room for the fee, the app locks a little less too. The wallet also needs at least 0.01 SOL for the lock's network fee and Streamflow's costs. There is no platform fee.

## Which tokens

Burn works for any token a wallet holds, on Solana and Robinhood Chain, whatever its [launchpad](https://vortexdeployer.com/docs/other/glossary#launchpad). Lock works for any Solana token. Robinhood Chain tokens cannot be locked here.

## Troubleshooting

- **The buttons are greyed out** — the wallet holds none of this token. Hover over a button: it says "Nothing to burn" or "Nothing to lock".
- **"wallet needs at least 0.01 SOL for the lock"** — add SOL to the wallet and try again. See [Fund wallets](https://vortexdeployer.com/docs/wallets/fund).
- **"Enter at most … , the wallet's holding."** — your amount is more than the wallet holds. Type less, or pick a percentage.
- **"Enter between 0.042 (1 hour) and 3650 days."** — the lock time is too short or too long. Pick a time in that range.

## See also

- [The terminal](https://vortexdeployer.com/docs/terminal/overview)
- [After launch](https://vortexdeployer.com/docs/launch/after-launch)
- [Close out](https://vortexdeployer.com/docs/launch/close-out)
- [Export a private key](https://vortexdeployer.com/docs/wallets/key-export)

---

# P&L share cards

> Make an image of your profit or loss on one token, or over a few days, to save or share.

Source: https://vortexdeployer.com/docs/terminal/pnl-cards · Markdown: https://vortexdeployer.com/docs/terminal/pnl-cards.md

A share card is an image of your [PnL](https://vortexdeployer.com/docs/other/glossary#pnl). There are two. The terminal makes one for a single token. The Dashboard makes one for a time period. Making a card spends nothing.

## Share a token's PnL

1. Open the token in the [terminal](https://vortexdeployer.com/docs/terminal/overview).
2. Press **Share PnL** at the top right.
3. A window opens with the card for all wallets attached to this token.
4. Set the options on the left.
5. Press one of the buttons at the bottom.

![The PnL card window for a token](https://vortexdeployer.com/docs/terminal/pnl-cards.png)

The card shows your PnL in large type, then **PNL %**, **INVESTED** and **POSITION**. Below the card, one line of text sums up the same figures.

Your open [bag](https://vortexdeployer.com/docs/other/glossary#bag) counts at what selling it all now would bring back. That is after the price moves and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee). It is not price times amount.

Options:

- **Card background** — **Default**, or **Custom image** to use a picture of your own.
- **Show ticker/name** — shows the token's ticker and name on the card.
- **Show @username** — puts your username on the card. It works only once you have a username. See [Profile](https://vortexdeployer.com/docs/account/profile).

Buttons:

- **Copy summary** — copies the one line of text.
- **Share to Discord** — posts the card to the community Discord.
- **Copy image** — copies the picture, so you can paste it anywhere.
- **Download PNG** — saves the picture as a file.

:::warning Copy and Download may post to Discord
The first time you press **Copy image** or **Download PNG**, the app also tries to post the card to the community Discord. If the card passes the rules below, it is posted and you see **Shared to Discord**. If not, nothing is posted and no message shows.
:::

## The Discord rules

The server checks its own figures, not the card's. A card is posted only when:

- your profit on the token is $300 or more,
- it beats the best card already shared for this token, and
- you haven't shared a card in the last few minutes.

The Discord gets the picture only, with no text.

## Share a period's PnL

1. Open the [Dashboard](https://vortexdeployer.com/docs/account/dashboard).
2. In the **Performance** panel, press **Share**.
3. Pick the **Card period**: **1D**, **7D** or **30D**. The default is **7D**.
4. Set **Card background** and **Show @username**.
5. Press **Copy** or **Download PNG**.

This card counts only finished trades: money from sells minus money spent on buys, per day in UTC time. Tokens you still hold are not counted. It shows your chain's coin, or USD when the Dashboard shows both chains. This card is never posted to Discord.

## Troubleshooting

- **"No wallets attached to this token"** — attach wallets in the **Wallets** tab first.
- **"PnL is still loading"** — wait a few seconds and press **Share PnL** again.
- **"Profit ($X) is below the $300 minimum to share"** — the Discord share needs $300 profit or more. You can still copy or save the card.
- **Share is greyed out on the Dashboard** — you have no finished trades yet, or your balances are hidden. Show balances to share.

## See also

- [Dashboard](https://vortexdeployer.com/docs/account/dashboard)
- [Portfolio](https://vortexdeployer.com/docs/account/portfolio)
- [The terminal](https://vortexdeployer.com/docs/terminal/overview)

---

# KOL tracker

> Keep a list of wallets to watch, and see their trades marked on the chart and in the Trades panel.

Source: https://vortexdeployer.com/docs/terminal/kol-tracker · Markdown: https://vortexdeployer.com/docs/terminal/kol-tracker.md

The **Tracker** holds your list of wallets to watch, such as well-known traders. A wallet on this list is often called a [KOL](https://vortexdeployer.com/docs/other/glossary#kol). When one of them trades the token you have open, the [terminal](https://vortexdeployer.com/docs/terminal/overview) shows it with the wallet's emoji and name. The tracker only watches. It never trades or spends anything.

## Open the tracker

- **On a computer** — press the wallet icon in the bar at the bottom of the screen. On wide screens it reads **Tracker**.
- **On a phone** — open the ☰ menu and press **KOL tracker**.

![The KOL tracker](https://vortexdeployer.com/docs/terminal/kol-tracker.png)

The window is titled **Tracker**. The top of the left side shows how many wallets you track. Your one list works in every terminal.

## Your starting list

Your list starts with a set of well-known trader wallets. They are yours to rename or remove.

## Track a wallet

1. On a narrow screen, press **Track wallet** above the list. On a wide screen, the form is always on the left.
2. Paste the address into **Wallet address**.
3. Type an **Emoji**. This is the mark you see on the chart.
4. Type a **Name**, up to 64 characters.
5. Press **Add**. You see "Wallet tracked" when it is saved.

Only Solana addresses can be added for now. The box says "Solana or EVM address", but an EVM address (one that starts with 0x) is refused.

- **Emoji** — optional. If you leave it empty, the Trades panel shows 💎 and the chart shows **B** or **S**.
- **Name** — optional. If you leave it empty, the list shows **Unnamed** and the terminal shows a short address.

## Change or remove a wallet

- **Change** — paste an address that is already on the list. The button reads **Update**. Fill in a new emoji or name and press **Update**. Empty fields stay as they were.
- **Find** — type in the **Name or address** box above the list.
- **Copy** — press the address on a row.
- **Remove** — press the bin on a row, then **Untrack**. The ✕ next to it keeps the wallet.

:::info An empty list fills itself again
If you remove every wallet, the starting list comes back the next time the tracker loads. Keep at least one wallet on the list to stop this.
:::

## Where tracked trades show

- **Trades panel** — the trader column shows the emoji and name instead of a short address. Click it to open the wallet on the explorer.
- **Chart** — a mark with the wallet's emoji sits on the candle where it traded. It is green for a buy and red for a sell. Hover it to read who traded and how much, such as "Cupsey bought 1.500 SOL".

:::tip Watch other devs
Add the dev wallets of tokens you follow. A sell from a dev wallet is often the first sign that a token is winding down.
:::

## Troubleshooting

- **"Already tracked — type a new name or emoji to update it."** — that address is on your list. Fill in a new name or emoji, or clear the address.
- **"Wallet address required"** — paste an address before you press **Add**.

## See also

- [The terminal](https://vortexdeployer.com/docs/terminal/overview)
- [Trade panel](https://vortexdeployer.com/docs/terminal/trade-panel)
- [XID feed](https://vortexdeployer.com/docs/xid/feed)

---

# How tasks run

> Learn what a task is, how to make one, pick its wallets, and start, pause, stop, edit or run it again.

Source: https://vortexdeployer.com/docs/tasks/overview · Markdown: https://vortexdeployer.com/docs/tasks/overview.md

A [task](https://vortexdeployer.com/docs/other/glossary#task) is a job your wallets do on one token, such as buying it, trading it or guarding it. You set it up once, start it, and follow every trade in its log.

:::warning Tasks spend real money
Tasks have no test mode, and the app has no dry run. A started task sends real transactions from your wallets, and a trade that lands cannot be undone. Some tasks offer a **Preview** that checks the plan and sends nothing (see below). See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Where your tasks are

Each task belongs to one token. Open the token in the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal). Its **Tasks** panel lists the token's tasks.

![The Tasks panel in the terminal: the All / Active menu, New task and the task lines](https://vortexdeployer.com/docs/tasks/overview.png)

- The menu at the top shows **All** tasks or only the **Active** ones.
- **New task** opens the form to make one.
- Each line shows a status dot, the task type, its name and its wallet count (for example "6w").
- Click a task's name to open its card.

## Make a task in the terminal

1. In the **Tasks** panel, press **New task**. The form opens with **Buy** picked.
2. Under **Task type**, pick the job. **Find a task** searches the list. Types are grouped into **Trade**, **Automate**, **Distribute** and **Launch**.
3. Fill in the settings. Settings you rarely change sit under **Advanced**.
4. Pick the wallets (see below).
5. Type a **Task name (optional)** so you can find it later.
6. Press **Create task**. To start at once, tick **Start immediately** first. The button then reads **Create & start**.

![Opening New task and switching between task types. Nothing is created.](https://vortexdeployer.com/docs/tasks/overview.mp4)

The form only offers wallets on the token's chain. To reuse settings, pick a saved [task preset](https://vortexdeployer.com/docs/other/glossary#task-preset) in **Load preset…**, or press **Save as preset** to keep the current ones.

Snipe is not in this list. You add it while you launch.

## Add tasks to a launch

The launch wizard has a **Tasks** step, so tasks can start the moment your token goes live.

1. On the **Wallets** step, add the wallets that will trade. The dev wallet does not count as one.
2. On the **Tasks** step, pick a task type. Once you have one, **Add task** adds more.
3. Set each task up the same way as in the form above.
4. Keep **Auto-start at launch** on to start the task as soon as the token is live. Turn it off and the task waits for you to start it.

The [Tasks step](https://vortexdeployer.com/docs/launch/tasks-step) page has the details.

## Pick wallets

The wallet list shows how many you picked, for example "Wallets (6 selected)".

- Tick wallets one by one, or press **All** to pick every wallet shown. **Clear** removes them all.
- Under **Select by role**, tick a [wallet role](https://vortexdeployer.com/docs/other/glossary#wallet-role), such as Bundle, to pick all its wallets.
- **Full screen** opens a bigger picker for long lists. It adds search and quick picks: **All**, **None**, **Invert**, **With balance** and **Select first N**.
- A wallet marked "Also in …" is already used by another task. Both tasks then spend the same SOL.

Some task types ask for an amount beside each wallet:

- Type an amount on a wallet's row, or press **Max** to use all it can spend. Max keeps back enough for the [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee) and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee).
- To give every picked wallet the same amount, type it in **Amount per wallet (SOL)** and press **Set all** (the button shows the wallet count).
- **Max all** sets each picked wallet to its own spendable balance.

In Buy, Snipe and Bundle, the wallets are numbered. Wallet 1 buys first. Drag a wallet, or use its arrows, to change the order.

## The dev wallet stays out unless you pick it

The [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet) is the wallet that created your token. Trading tasks leave it out, so a task never buys or sells from it by surprise. Quick picks such as **All** skip it too.

To trade with it, tick it yourself, or turn on the switch the form shows: **Buy with the dev wallet**, **Dev wallet trades** or **Sell from the dev wallet**. A task that uses the dev wallet says "incl. dev" on its card.

## Start, pause and stop

| Button | What it does |
|---|---|
| **Start** | Starts the task. |
| **Pause** | Halts the task. Nothing is sold. |
| **Resume** | Goes on from where it paused, in the same attempt. |
| **Stop** | Ends the task. You confirm with the check mark. Nothing is sold or undone. |
| **Run again** | Starts a finished task over. |

In the **Tasks** panel these are small play, pause and stop icons. On the open card they carry words.

A task shows one of these statuses:

- **IDLE** — created, not started yet.
- **RUNNING** — working now.
- **PAUSED** — halted until you press **Resume**.
- **COMPLETED** — it finished its job.
- **STOPPED** — you stopped it.
- **FAILED** — it hit a problem. The card shows the last error.
- **TIMEOUT** — it ran past its time limit.

A task also fails after too many errors in a row. **Stop after repeated errors** under **Advanced** sets how many.

## Run again

When a task has finished, **Start** turns into **Run again**. Run again is a new attempt. It starts from zero at the first wallet, with the same settings, as if the task were new.

- From the second run on, the card shows an "Attempt 2" chip (then 3, 4 and so on).
- The log groups trades under "Attempt N" headings, newest first.
- **Results** adds up all attempts.

A finished task keeps its settings as a record, so you cannot change them. To run it with new settings, press **Duplicate**. It makes a copy marked "(copy)" that waits for you to start it.

## Edit a task

Press the pencil icon (**Edit**) on the card.

- **Not started or paused** — change the name, the wallets and the settings.
- **Running** — saving applies the new settings at once, in the same attempt. Wallets that already traded in this attempt do not trade again.
- **Finished** — only the name can change.

To remove a task, stop it, then press **Delete task** and **Confirm delete**. A running or paused task cannot be deleted.

## The task card and its log

The card shows the status, the wallets and the task number. Its sections are:

- **Executions** — every transaction: When, Wallet, Side, SOL, Sig (the transaction's ID) and Status. A failed row gives the reason. **Load older** shows more.
- **Results** — how each wallet did: Landed, Failed, Skipped or No action, with reasons. **Replay timeline** lists the task's events in order.
- **Preview** — only on Buy, Snipe, Migrate & Buy, Token Sender and Wallet warm-up. It checks what the task would do right now and sends nothing. A buy task shows which wallets "will buy" or "skip", the total cost, and whether the trade "would land". Token Sender and Wallet warm-up show a short summary of the plan instead. "Would fail to start." means the task cannot start as set up. **Recompute** checks again.

![An open task card](https://vortexdeployer.com/docs/tasks/task-card.png)

:::tip Preview before you start
Create the task without **Start immediately**. Open **Preview**, and press **Start** only when it looks right.
:::

## What tasks cost

Every buy and sell a task makes pays the network fee and the platform fee. Some tasks also pay a [Jito tip](https://vortexdeployer.com/docs/other/glossary#jito-tip) or a price of their own. Each task page says which. See [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees).

## See also

- [Buy](https://vortexdeployer.com/docs/tasks/buy)
- [Volume](https://vortexdeployer.com/docs/tasks/volume)
- [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run)
- [Tasks API](https://vortexdeployer.com/docs/api/tasks)

---

# Buy

> Buy a token from many of your wallets in one round, with your choice of amounts and timing.

Source: https://vortexdeployer.com/docs/tasks/buy · Markdown: https://vortexdeployer.com/docs/tasks/buy.md

Buy makes each wallet you pick buy the token once. Use it to spread a buy over many wallets, with a short random wait between them.

## Before you start

- The token is live and can be traded.
- Each wallet holds SOL for its buy, plus the [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee) and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee).

## Set up a Buy

1. Open the token in the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal). In **Tasks**, press **New task**. **Buy** is already picked.
2. Choose a **Buy mode** (see below) and fill in its amounts.
3. Pick the wallets. Wallet 1 buys first. Drag a wallet to change the order.
4. Open **Advanced** if you want to change the waits or limits.
5. Press **Create task**.
6. Open **Preview** on the task card. It shows what each wallet would buy right now, and sends nothing.
7. Press **Start**.

![The Buy form with its buy modes and the wallets](https://vortexdeployer.com/docs/tasks/buy.png)

The task ends when every wallet has had its turn. To buy again with the same setup, press **Run again**.

## Buy modes

- **Available balance (keeps fees)** — the default. Each wallet buys with all its SOL, minus what it needs for fees.
- **Set SOL for each wallet** — type an amount beside each wallet in **Per-wallet SOL**. A wallet with no amount is skipped. A wallet that cannot pay its amount plus fees is skipped too. Its buy is not made smaller.
- **Random % of balance** — each wallet spends a random share of its SOL, between **Min %** and **Max %**. Default 10–50%.
- **SOL between two amounts** — each wallet buys a random amount between **Minimum buy amount** and **Maximum buy amount**. Default 0.01–0.1 SOL.
- **One total across wallets** — set one **Total to spend** (default 0.1 SOL) for the whole round.
  - **Split** shares it out: **Equal shares**, **Random shares** or **Weighted by balance**.
  - **Wallets** picks who takes part, such as **Richest first** or **Random pick**.
  - **How many** keeps that many wallets. 0 means all of them.
  - A wallet that cannot carry its share buys what it can. The rest moves to the other wallets.

## Key settings

These sit under **Advanced**.

- **Shortest wait between trades** and **Longest wait between trades** — a random wait between two wallets. Default 1000–5000 ms (1 to 5 seconds). Set both to 0 and every wallet buys at once.
- **Initial delay** — a wait before the first buy. Default 0.
- **Min wallet balance** — wallets with less SOL than this are skipped. Default 0.01 SOL.
- **Slippage** — how far the price may move against you before a buy is refused. Default 500 [basis points](https://vortexdeployer.com/docs/other/glossary#bps), which is 5%.
- **Supply guard** — off by default. When on, the round stops partway if outside buyers take more than **Max supply change** (default 5%) of the [supply](https://vortexdeployer.com/docs/other/glossary#supply) while your wallets buy. pump.fun tokens only.
- **Max supply per wallet** — a wallet that already holds this share of the supply is skipped. 0 means off.

The task leaves out your [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet). Turn on **Buy with the dev wallet** to include it.

:::warning Every buy spends real SOL
A buy that lands is final. The task cannot undo it. Every buy also pays the network fee and the platform fee. With **Available balance (keeps fees)**, each wallet spends nearly all its SOL, so check **Preview** first. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::tip Many buys at the same moment
Set both waits to 0 to fire every wallet at once. For buys that must all land together or not at all, use [Bundle](https://vortexdeployer.com/docs/tasks/bundle).
:::

## Troubleshooting

- **A wallet shows "skip" in Preview** — it has less SOL than **Min wallet balance**, or less than its amount plus fees. Add SOL or lower the amount.
- **The round stopped early** — **Supply guard** saw outside buyers take too much. **Results** on the card lists which wallets bought.

## Every setting

@engine(buy)

## See also

- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Snipe](https://vortexdeployer.com/docs/tasks/snipe)
- [Bundle](https://vortexdeployer.com/docs/tasks/bundle)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)

---

# Snipe

> Buy your own new token from many wallets as soon as your launch goes live.

Source: https://vortexdeployer.com/docs/tasks/snipe · Markdown: https://vortexdeployer.com/docs/tasks/snipe.md

Snipe is a [Buy](https://vortexdeployer.com/docs/tasks/buy) for your own launch. Its wallets all buy at once, as soon as the new token is live. You add it while you launch, so it is not in **New task**.

## Before you start

- You are launching a token with the launch wizard or with Quick deploy.
- You added trading wallets on the wizard's **Wallets** step. The [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet) does not count as one.
- Each wallet holds SOL (ETH on Robinhood Chain) for its buy, plus fees.

## Add a Snipe to a launch

1. In the launch wizard, go to the **Tasks** step.
2. Pick **Snipe** in the task list. If the step already has a task, press **Add task** first.
3. Pick the wallets and a **Buy mode**. The modes work the same as in Buy.
4. Optional: check your share of the token with the supply calculator (below).
5. Keep **Auto-start at launch** on. The Snipe then buys as soon as the token is live. If you turn it off, the task waits for you to start it.
6. Finish the wizard and press **Create**.

![A Snipe on the Tasks step of the wizard](https://vortexdeployer.com/docs/tasks/snipe.png)

To add a Snipe to every Quick deploy, put it in a preset's launch tasks. See [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy).

## Key settings

Snipe has the same settings as Buy, minus the waits. Every wallet buys at once.

- **Buy mode** — how much each wallet spends. The default, **Available balance (keeps fees)**, spends nearly all of each wallet's SOL.
- **Min wallet balance** — wallets with less are skipped. Default 0.01 SOL.
- **Slippage** — default 500 [basis points](https://vortexdeployer.com/docs/other/glossary#bps) (5%).
- **Supply guard** and **Max supply per wallet** — the same limits as in Buy.
- **Buy with the dev wallet** — off by default, so the dev wallet does not snipe.

## The supply calculator

The Snipe card can show what share of the token's [supply](https://vortexdeployer.com/docs/other/glossary#supply) your buys would get.

1. Optional: type a **Max supply** in %. The launch then refuses a plan above it.
2. Press **Calculate supply %**. The card lists each wallet's share and the running total.
3. If a wallet would go past your max, press **Apply capped amounts** to trim it.
4. After you change an amount, press **Recalculate supply %**.

The figure is a best case. It assumes no one else buys between your wallets. If another buyer lands first, you get less of the supply for the same SOL, never more. It is exact for pump.fun and pons. On other launchpads it is an estimate.

:::warning Snipe buys for real
When the launch goes live, the Snipe spends real SOL from every wallet. A buy that lands cannot be undone. Each buy pays the [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee) and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee). See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::info pons launches
On [pons](https://vortexdeployer.com/docs/other/glossary#pons), early buyers pay a [snipe tax](https://vortexdeployer.com/docs/other/glossary#snipe-tax). Snipe wallets on your own pons launch do not pay it. One launch can shield at most 31 wallets. If you pick more, the wizard asks you to move some to a Buy task with a delay.
:::

:::tip Snipe or Bundle?
On Solana, a [Bundle](https://vortexdeployer.com/docs/tasks/bundle) with **Auto-start at launch** joins the launch itself. Its buys land together with the token's creation, or the launch does not happen. A Snipe buys right after the token is live, so another buyer may land first.
:::

## Every setting

@engine(sniper)

## See also

- [Tasks step](https://vortexdeployer.com/docs/launch/tasks-step)
- [Buy](https://vortexdeployer.com/docs/tasks/buy)
- [Bundle](https://vortexdeployer.com/docs/tasks/bundle)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)

---

# Volume

> Keep your token trading with timed buys or sells, or a fast mix of both, across your wallets.

Source: https://vortexdeployer.com/docs/tasks/volume · Markdown: https://vortexdeployer.com/docs/tasks/volume.md

Volume makes your wallets trade the token again and again. Each trade is a real buy or sell, so the chart shows activity and [volume](https://vortexdeployer.com/docs/other/glossary#volume). You choose one of two styles.

- **Scheduled — one side, fixed interval** — only buys, or only sells, one wallet per trade, on a timer.
- **Mixed — fast random buys and sells** — each trade picks a side, a wallet and a size at random. It can run several trades at the same time.

You cannot change the style after the task is created.

## Before you start

- The token is live and can be traded.
- Your wallets hold SOL for buys and fees. For sells, they also hold the token.

## Set up Volume

1. Open the token in the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal). In **Tasks**, press **New task**.
2. Under **Task type**, pick **Volume**.
3. Choose a **Volume style**, and fill in its settings (below).
4. Pick the wallets. The task takes turns between them, so more wallets show more traders.
5. Press **Create task**, then **Start**.

![The Volume form with its volume styles](https://vortexdeployer.com/docs/tasks/volume.png)

Volume has no **Preview**. It trades for real from the moment it starts.

## Scheduled settings

- **Trading plan** — **Bullish — scheduled buys** or **Bearish — scheduled sells**. The names say what the task does. They do not predict the price.
- **Buy amount per trade** — SOL for each buy. Default 0.01 SOL.
- **Total buy budget** — the most all wallets spend on buys together. Default 0.1 SOL. Fees come on top.
- **Tokens to sell per trade** — for sells, the share of the wallet's tokens to sell each time. Default 10%. Wallets with no tokens are skipped.
- **Time between trades** — default 60 seconds.
- **Maximum trades** — default 10. Trades that fail still count.
- **Stop after** (under **Advanced**) — a time limit in minutes, counted from each start or resume. Default 60.

The task stops at **Maximum trades**, the time limit or the budget, whichever comes first.

## Mixed settings

- **Buy power** and **Sell power** — how often it buys versus sells. 50 / 50 is even. 70 / 30 buys more often. 100 / 0 only buys.
- **Buy sizing** — **Random size in a band** buys between **Min buy** and **Max buy** (default 0.01–0.1 SOL). **Reach a volume target in a window** aims for a **Target volume** in SOL **Within** a number of minutes.
- **Min sell** and **Max sell** — each sell takes a random share of the wallet's tokens. Default 10–50%.
- **Shortest wait between trades** and **Longest wait between trades** — the wait before the next trade is sent. Default 1000–5000 ms (1 to 5 seconds).

Under **Advanced**:

- **Trades at once** — how many trades may be on their way together, each from a different wallet. Default 1, up to 50.
- **Most trades on one side in a row** — after this many buys in a row, the next trade sells, and the other way round. Default 3. 0 turns it off.
- **Net-buy cap** — the most SOL the run may spend on buys beyond what its sells bring back. At the cap, every trade sells. 0 turns it off.
- **Min SOL reserve** — SOL each wallet always keeps. Default 0.
- **Maximum trades** — 0 (the default) runs until you stop it.
- **Look like trading bots** — Solana only. Pick bots such as Photon or Axiom. Each trade then also sends 0.00000001 SOL to that bot's fee wallet, so explorers label the trade as made through the bot.

## Settings in both styles

- **Slippage** (under **Advanced**) — default 500 [basis points](https://vortexdeployer.com/docs/other/glossary#bps) (5%).
- **Maximum supply per wallet** (under **Advanced**) — skips buying with a wallet that already holds this share of the [supply](https://vortexdeployer.com/docs/other/glossary#supply). 0 means no limit.
- **Dev wallet trades** — off by default, so your [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet) does not trade.

:::warning Every trade costs money
Each trade pays the [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee) and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee). Each sell also gets back a bit less than its buy cost, because of the price move and [slippage](https://vortexdeployer.com/docs/other/glossary#slippage). A fast Mixed run can make hundreds of trades a minute. Set **Maximum trades**, a volume target or a time limit before you start. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::tip Going fast
For 10 or more trades a second, set the waits to 50–100 ms, **Trades at once** to 10 or more, and pick at least that many wallets.
:::

## Troubleshooting

- **Sells are skipped** — those wallets hold none of the token. Buy first, or use the Bullish plan.
- **Buys stopped early** — in Scheduled, the **Total buy budget** is spent. In Mixed, a wallet may be down to its **Min SOL reserve**.

## Every setting

@engine(volume)

## See also

- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Fake volume](https://vortexdeployer.com/docs/tasks/fake-volume)
- [Hand Switcher](https://vortexdeployer.com/docs/tasks/hand-switcher)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)

---

# Fake volume

> Add trading volume to a Solana token with two of your wallets, while most of the SOL comes back.

Source: https://vortexdeployer.com/docs/tasks/fake-volume · Markdown: https://vortexdeployer.com/docs/tasks/fake-volume.md

Fake Volume makes your token's [volume](https://vortexdeployer.com/docs/other/glossary#volume) go up without you keeping a position. Two of your wallets buy and sell through short-lived wallets, and most of the SOL returns each round. Solana only.

## What happens on-chain

The task works in cycles. Each cycle is five transactions sent as one [Jito bundle](https://vortexdeployer.com/docs/other/glossary#jito-bundle), so they all land together or none do.

1. Your two wallets send SOL to two new [temporary wallets](https://vortexdeployer.com/docs/other/glossary#temporary-wallet). The task makes fresh ones every cycle.
2. Each temporary wallet buys the token. Then it passes the tokens to a second temporary wallet.
3. Each second wallet sells all the tokens and sends the SOL back to your wallet.
4. The temporary accounts are closed. Any SOL left in them is sent back to your wallets after the bundle lands.

On the chart, each cycle shows two buys and two sells from four new wallets. The SOL spent on the buys counts as the volume. When the cycle ends, no one holds the new tokens and your wallets have their SOL back, minus the costs.

## Before you start

- You have exactly two wallets with SOL on Solana. Each keeps 0.005 SOL that the task never spends.
- The token is live and can be traded.

## Set up Fake Volume

1. Open the token in the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal). In **Tasks**, press **New task**.
2. Under **Task type**, pick **Fake Volume**.
3. Type a **Target volume** in USD.
4. Set **Max SOL per cycle**.
5. Pick exactly two wallets.
6. Press **Create task**, then **Start**.

![The Fake Volume form: target volume, SOL per cycle and the wallets](https://vortexdeployer.com/docs/tasks/fake-volume.png)

There is no **Preview** for this task. It runs for real from the start.

## Key settings

- **Target volume** — the task stops when the printed volume reaches this many US dollars. Required.
- **Max SOL per cycle** — the most SOL both wallets put into one cycle together. Default 0.1 SOL, at least 0.036 SOL. The task splits it at random between your two wallets.
- **Max cycles** — stop after this many cycles. 0 (the default) runs until the target is met.
- **Shortest wait between cycles** and **Longest wait between cycles** (under **Advanced**) — a random wait between cycles. Default 1000–5000 ms (1 to 5 seconds).
- **Jito tip** (under **Advanced**) — paid once per cycle to get the bundle included. The default, 1,000,000, is 0.001 SOL.
- **Priority fee** (under **Advanced**) — an extra fee per transaction, in SOL. Default 0.
- **Slippage** (under **Advanced**) — default 500 [basis points](https://vortexdeployer.com/docs/other/glossary#bps) (5%).
- **Stop after repeated errors** (under **Advanced**) — default 10.

## What it costs

Most of the SOL you put into a cycle comes back. Each cycle costs:

- the Jito tip,
- the [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee) on five transactions, plus any priority fee,
- the trading fee the pool takes on each buy and each sell,
- a small loss from the price move between the buy and the sell.

The temporary wallets are not your saved wallets, so their trades do not pay the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee).

:::warning Real SOL, no real buyers
Every cycle spends real SOL, and a landed cycle cannot be undone. The volume comes from your own money trading with itself. It adds no lasting holders and no real buyers. Fees add up fast, so set **Max cycles** or a modest target, and watch the first few cycles. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::info Need holders instead?
Fake Volume leaves no holders behind. To raise the holder count, use [Holder boost](https://vortexdeployer.com/docs/tasks/holder-boost).
:::

## Troubleshooting

- **"requires EXACTLY 2 wallets"** — edit the task and pick two wallets, no more and no fewer.
- **"wallets cannot fund a cycle"** — a wallet has too little SOL above its reserve. Add SOL, or raise **Max SOL per cycle** if it is close to 0.036.
- **The task failed with "none landed"** — no bundle got in. Raise the **Jito tip** and try again.

## Every setting

@engine(fakevolume)

## See also

- [Volume](https://vortexdeployer.com/docs/tasks/volume)
- [Holder boost](https://vortexdeployer.com/docs/tasks/holder-boost)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)

---

# Holder boost

> Raise your token's holder count by sending a tiny amount to new wallets, and get the rent back later.

Source: https://vortexdeployer.com/docs/tasks/holder-boost · Markdown: https://vortexdeployer.com/docs/tasks/holder-boost.md

Holder Boost raises the number of [holders](https://vortexdeployer.com/docs/other/glossary#holder) explorers show for your token. It makes new wallets and sends each one a tiny amount of the token. It does not buy or sell anything.

## What happens on-chain

On Solana, for each new holder:

1. The task makes a fresh wallet and adds it to your **Wallets** page. It gets the role Holder and the name `holder-t` plus the task number.
2. One of the wallets you picked opens a [token account](https://vortexdeployer.com/docs/other/glossary#token-account) for the new holder and pays its [rent](https://vortexdeployer.com/docs/other/glossary#rent).
3. That wallet sends the new holder a tiny amount of your token.

Up to 8 holders go in each transaction. The new holders get tokens only, no SOL.

On Robinhood Chain there is no rent. Your wallet pays only gas, and up to 200 holders go in one transaction.

## Before you start

- The wallets you pick hold the token. They must have enough to give every holder their share.
- On Solana, they also hold SOL for the rent and fees. On Robinhood Chain, ETH for gas.

## Set up Holder Boost

1. Open the token in the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal). In **Tasks**, press **New task**.
2. Under **Task type**, pick **Holder Boost**.
3. Keep **Mode** on **Boost (create holders)**.
4. Set **Holder count** and **Raw units per holder**.
5. Pick the wallets that send the tokens.
6. Check the **Estimated cost** line on the form.
7. Press **Create task**, then **Start**.

![The Holder Boost form: mode, holder count and the cost line](https://vortexdeployer.com/docs/tasks/holder-boost.png)

## Key settings

- **Mode** — **Boost (create holders)** or **Reclaim (burn + close)**. Reclaim is Solana only.
- **Holder count** — how many new holders to make. Default 10.
- **Raw units per holder** — how much each holder gets, in the token's smallest unit. Default 1. A pump.fun token has 6 decimals, so 1 whole token is 1,000,000 units. At 18 decimals, 1 token is 1 followed by 18 zeros.
- **Delay between batches** (under **Advanced**) — the wait between transactions. Default 500 ms.
- **Rent recipient** (Reclaim only) — the wallet that gets the rent back. If you leave it empty, it goes to the first wallet of the task.
- **Stop after repeated errors** (under **Advanced**) — default 10.

## What it costs

On Solana, each new holder needs a token account. Your wallet pays about 0.00204 SOL of rent for each one, plus a small fee per transaction. The form shows the total as **Estimated cost: ATA rent**. For example, 100 holders cost about 0.204 SOL. The tokens you give away come on top.

These are transfers, not trades, so there is no [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee).

:::warning Real SOL and real tokens
The rent and the tokens leave your wallets as soon as the task runs. The tokens you send do not come back. The rent comes back only if you run Reclaim later. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Get the rent back with Reclaim

When you no longer need the extra holders, run Reclaim on the same token (Solana only).

1. Make a new Holder Boost task on the token.
2. Set **Mode** to **Reclaim (burn + close)**.
3. Optional: pick a **Rent recipient**.
4. Press **Create task**, then **Start**.

Reclaim covers the holder wallets made by all your Holder Boost tasks on this token, and no one else's. It [burns](https://vortexdeployer.com/docs/other/glossary#burn) the tokens in each of them, which destroys them. Then it closes their token accounts and sends the rent to the recipient. That wallet also pays the network fees. Your holder count drops back down.

:::info Holders, not buyers
These holders never bought the token, and anyone can see they got it by transfer. To add trading activity instead, see [Volume](https://vortexdeployer.com/docs/tasks/volume) or [Pro trader boost](https://vortexdeployer.com/docs/tasks/pro-trader-boost).
:::

## Troubleshooting

- **"no source wallet holds this token"** — none of the picked wallets has the token. Pick wallets that hold it, or buy some first.

## Every setting

@engine(holderboost)

## See also

- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Fake volume](https://vortexdeployer.com/docs/tasks/fake-volume)
- [Pro trader boost](https://vortexdeployer.com/docs/tasks/pro-trader-boost)
- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)

---

# Pro trader boost

> Pay a fixed price to have the platform's aged trader wallets each buy about one token of yours.

Source: https://vortexdeployer.com/docs/tasks/pro-trader-boost · Markdown: https://vortexdeployer.com/docs/tasks/pro-trader-boost.md

Pro Trader Boost puts experienced-looking buyers on your chart. You pay a price by tier, and the platform's own [aged](https://vortexdeployer.com/docs/other/glossary#aged-wallet) trader wallets each buy a small amount of your token.

## What happens on-chain

On Solana:

1. The task takes the tier price in SOL from the wallets you picked. It takes from the richest wallet first, and each wallet keeps 0.03 SOL.
2. The platform picks that many of its own trader wallets. These wallets are aged and have a real trading history.
3. Each of them buys about one whole token of yours, with its own SOL. Each buy is marked as made through a known trading bot.
4. The tokens stay in the platform's wallets. They never show on your **Wallets** page, and they are not yours.

A platform wallet never buys the same token twice. Your own wallets only pay the price. They make no trades.

On Robinhood Chain there are no platform wallets. The task's own funded wallets make the buys, and no tier price is charged.

## Prices

**Pro traders** is the number of buyers you want. The price is per tier.

| Traders | Price |
|---|---|
| 10 | $5 |
| 20 | $9 |
| 30 | $12.50 |
| 40 | $16 |
| 50 | $18.75 |
| 70 | $24.50 |
| 100 | $32.50 |
| 150 | $45 |
| 300 | $82.50 |
| 500 | $125 |

- A count between two tiers uses the lower tier, and you get that tier's count. For example, 25 gets the 20 tier.
- A count below 10 gets the 10 tier.
- Above 500, each trader costs $0.25.
- The price is paid in SOL at the current SOL price.

## Before you start

- The token has a pool you can trade on. If it has none, the task fails before it takes the price.
- The wallets you pick hold enough SOL for the price, plus 0.03 SOL each.

## Set up Pro Trader Boost

1. Open the token in the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal). In **Tasks**, press **New task**.
2. Under **Task type**, pick **Pro Trader Boost**.
3. Set **Pro traders**. Default 10.
4. Pick the wallets that will pay.
5. Press **Create task**, then **Start**.

![The Pro Trader Boost form: how many pro traders and the paying wallets](https://vortexdeployer.com/docs/tasks/pro-trader-boost.png)

There is no **Preview** for this task.

## Key settings

These sit under **Advanced**.

- **Delay between buys** — the wait between two trader buys. Default 500 ms.
- **Slippage** — default 2500 [basis points](https://vortexdeployer.com/docs/other/glossary#bps) (25%), up to 10000.
- **Tries per buy** — how often one trader's buy is retried. Default 5.
- **Stop after zero prices** — the task fails after this many zero price reads. That happens when the token moved to a new pool or its pool ran dry. Default 3.
- **Stop after repeated errors** — default 10.

## How the price is taken

- If your wallets cannot cover the tier, the task drops to the biggest tier they can pay.
- If they cannot pay even the $5 tier, the task fails and takes nothing.
- If less than 95% of the price comes through, the task fails and no boost runs. What was already paid is kept.
- There may be fewer platform wallets left that have not bought your token. The tier is then cut to what they can deliver.

:::warning One price per run
The task takes the tier price once per run. **Start** and **Run again** each begin a new run, so each one charges the full price. **Resume** after a pause and saving an edit while it runs do not charge again. The run then buys only the traders its paid tier still owes. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::warning No refund for missed buys
The price is paid before any buy. Some trader buys may fail, fewer platform wallets may be ready, or the token may move to a new pool partway. In each case the price is not given back. This is not the trading [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee). It is a separate price for the service.
:::

## Troubleshooting

- **"insufficient funds for the fee"** — your wallets cannot pay the $5 tier after keeping 0.03 SOL each. Add SOL to them.
- **"no pool with liquidity for this mint"** — the token cannot be traded yet. Nothing was taken.
- **"no pro-trader wallet left that has not bought this mint"** — every platform wallet already bought this token.
- **"this run's fee collection fell short"** — less than 95% of the price came through, so no boost ran. **Run again** starts a new run, and it charges the price again.
- **"this run's fee collection was interrupted before it finished"** — the task stopped while it was taking the price. It fails and never charges this run again. Ask [Support](https://vortexdeployer.com/docs/account/support) to check what was taken.

## Every setting

@engine(protrader_boost)

## See also

- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Holder boost](https://vortexdeployer.com/docs/tasks/holder-boost)
- [Volume](https://vortexdeployer.com/docs/tasks/volume)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)

---

# Migrate & buy

> Plan a pump.fun launch that fills its curve, moves to PumpSwap and buys there, all in one bundle.

Source: https://vortexdeployer.com/docs/tasks/migrate-and-buy · Markdown: https://vortexdeployer.com/docs/tasks/migrate-and-buy.md

Migrate & Buy plans a new pump.fun token that skips the [bonding curve](https://vortexdeployer.com/docs/other/glossary#bonding-curve) stage. It creates the token, buys the whole curve so the token [migrates](https://vortexdeployer.com/docs/other/glossary#migration) at once, and then buys on [PumpSwap](https://vortexdeployer.com/docs/other/glossary#pumpswap). Solana only.

:::warning This task cannot run for real yet
The platform has not switched on real sends for this task. If you press **Start**, the task fails before it sends anything. No token is made and no SOL is spent. You can still build the task and read its **Preview**.
:::

## What it would do on-chain

All steps go in one [Jito bundle](https://vortexdeployer.com/docs/other/glossary#jito-bundle), so they all land together or none do.

1. The first wallet you pick is the dev wallet. It creates the new token.
2. The dev wallet buys the whole bonding curve. That fills the curve, so the token is ready to move.
3. The dev wallet moves the token to a PumpSwap pool.
4. Your other wallets buy the token in that pool.

A bundle holds at most 5 transactions. The first three are fixed, so at most two transactions of buyers fit.

## Set up Migrate & Buy

1. Upload your token's details as a JSON file to IPFS, a public file store, and copy its link. The app does not upload it for you.
2. Open any token in the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal). In **Tasks**, press **New task**. The task makes its own new token, so the open token is not used.
3. Under **Task type**, pick **Migrate & Buy** in the **Launch** group.
4. Fill in **Token name**, **Symbol** and **Metadata URI**.
5. Set **PumpSwap buy**.
6. Pick at least two wallets. The first is the dev wallet. The rest are buyers.
7. Press **Create task**, then open **Preview**.

![The Migrate & Buy form](https://vortexdeployer.com/docs/tasks/migrate-and-buy.png)

## Key settings

- **Token name** — 1 to 32 characters.
- **Symbol** — 1 to 16 characters.
- **Metadata URI** — the IPFS link to the JSON file you uploaded. See [metadata URI](https://vortexdeployer.com/docs/other/glossary#metadata-uri).
- **PumpSwap buy** — the total SOL your buyers spend after the move, split evenly between them. At least 0.001 SOL.
- **Per-buyer SOL (optional)** — set each buyer's amount yourself instead of an even split.
- **Mayhem mode** — the pump.fun launch option of the same name. Off by default.
- **Buyers / tx** (under **Advanced**) — how many buyers share one transaction, 1 to 3. Default 1.
- **Dev-buy slippage** and **PumpSwap slippage** (under **Advanced**) — default 1500 [basis points](https://vortexdeployer.com/docs/other/glossary#bps) (15%) each.
- **Jito tip** (under **Advanced**) — the default, 2,000,000, is 0.002 SOL.

## What the Preview shows

**Preview** lists the plan and sends nothing:

- **Dev full-curve buy** — the SOL the dev wallet needs to fill the curve. On pump.fun this is tens of SOL.
- **Dev balance** — whether the dev wallet can cover it.
- **Buyers** — how many buyer wallets have enough SOL.
- **Total plan cost** — the curve buy, the buyer buys and the tip together.
- **Bundle size** — the number of transactions against the limit of 5.
- **Real send** — while it reads "dry-run only", a real start is refused.

:::info Launch from the wizard instead
To launch a token today, use the launch wizard. See [Create a project](https://vortexdeployer.com/docs/launch/create-project).
:::

## Every setting

@engine(migrate_and_buy)

## See also

- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Bundle](https://vortexdeployer.com/docs/tasks/bundle)
- [Create a project](https://vortexdeployer.com/docs/launch/create-project)

---

# Anti-Sniper

> Watch outside buyers on your token and sell, or stop your other tasks, when they take too much.

Source: https://vortexdeployer.com/docs/tasks/anti-sniper · Markdown: https://vortexdeployer.com/docs/tasks/anti-sniper.md

Anti-Sniper watches who else buys your token. When outside buyers hold too much of the [supply](https://vortexdeployer.com/docs/other/glossary#supply), or spend too much, it acts once. It can sell all your tokens, or stop your other tasks on the token. It is made for the first minutes after a launch, when [snipers](https://vortexdeployer.com/docs/other/glossary#sniper) buy in early.

## How it decides

- It counts only trades made after the task starts.
- Your own wallets never count as outside buyers. That means every wallet you have on this chain, not just the task's wallets.
- Addresses you list under **Ignore buyers (addresses)** never count either.
- When an outside wallet sells, its share goes down again.
- The spend threshold adds up only buys paid in SOL (ETH on Robinhood Chain). Buys in a pool priced in another token count toward the supply threshold only.
- The first threshold reached sets off the action. The action runs once, and then the task ends.
- If **Monitor for** runs out first, the task ends and does nothing.

## Before you start

- For **Emergency sell all**, the wallets you pick hold the token and a little SOL for fees.
- To guard a launch from its first block, add the task in the launch wizard (below).

## Set up Anti-Sniper

1. Open the token in the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal). In **Tasks**, press **New task**.
2. Under **Task type**, pick **Anti-Sniper**.
3. Set **Supply threshold**, **Spend threshold**, or both.
4. Choose the **Action**.
5. Pick the wallets. For **Emergency sell all**, these are the wallets it sells from.
6. Press **Create task**, then **Start**.

![The Anti-Sniper form: thresholds, the action and the wallets](https://vortexdeployer.com/docs/tasks/anti-sniper.png)

There is no **Preview** for this task.

## Add it to a launch

1. In the launch wizard, go to the Tasks step and add **Anti-Sniper**.
2. Set it up as above.
3. Turn on **Auto-start at launch**. The task then starts watching as soon as the token is made.

See [Tasks step](https://vortexdeployer.com/docs/launch/tasks-step).

## Key settings

- **Supply threshold** — the share of the supply, in %, that outside buyers hold together.
- **Spend threshold** — the total SOL outside buyers spent on the token.
- **Action** — what happens when a threshold is reached:
  - **Emergency sell all** sells every token in the task's wallets at once.
  - **Stop our buys** stops every other running task you have on this token. It sells nothing.
- **Sell from the dev wallet** — shown for **Emergency sell all**. Off by default, so your [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet) keeps its tokens. Turn it on to sell those too.

Under **Advanced**:

- **Monitor for** — how many seconds to watch. When it runs out, the task ends without selling. Leave it empty to watch until you stop the task.
- **Total supply (raw)** — leave it empty. The task then reads the supply from the chain.
- **Ignore buyers (addresses)** — wallets that are not snipers, such as a partner or a market maker.
- **Slippage** — default 5000 [basis points](https://vortexdeployer.com/docs/other/glossary#bps) (50%). It is high so the sell goes through while the price falls.
- **Priority fee** — default 250000. That is about five times the normal fee, roughly 0.00005 SOL per wallet. It helps the sell get into an early block. See [priority fee](https://vortexdeployer.com/docs/other/glossary#priority-fee).

:::danger The sell is fast, not careful
**Emergency sell all** sells everything at once, with up to 50% [slippage](https://vortexdeployer.com/docs/other/glossary#slippage). Your own sell pushes the price down, so you may get much less than the tokens were worth a moment before. Landed sells cannot be undone. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::warning Stop our buys stops more than buys
**Stop our buys** stops every other running task you have on this token. That includes sells, Volume and limit orders, not only buys. Start the ones you still need again by hand.
:::

## Troubleshooting

- **"Set a supply threshold and/or a spend threshold"** — fill in at least one of the two.
- **"wallet sell(s) failed or remain unconfirmed"** — some sells did not land. The sells that did land stay done. Check the task log, then sell the rest from the [Sell all](https://vortexdeployer.com/docs/terminal/sell-all) control.
- **The action never fired** — buys from before the start do not count, and neither do your own wallets. A spend threshold also skips pools priced in another token.

## Every setting

@engine(antisniper)

## See also

- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Tasks step](https://vortexdeployer.com/docs/launch/tasks-step)
- [Snipe](https://vortexdeployer.com/docs/tasks/snipe)
- [Sell all](https://vortexdeployer.com/docs/terminal/sell-all)

---

# Bundle

> Buy from many wallets at the same moment in one Solana bundle, on a live token or as part of a launch.

Source: https://vortexdeployer.com/docs/tasks/bundle · Markdown: https://vortexdeployer.com/docs/tasks/bundle.md

Bundle buys your token from many wallets at once. All the buys go in one [Jito bundle](https://vortexdeployer.com/docs/other/glossary#jito-bundle), so they land in the same block, or none of them land. Use it for a strong first buy at a launch, or to enter a live token from many wallets together. Solana only.

## Before you start

- Each wallet holds the SOL it will spend, plus 0.008 SOL and 2% of its amount for its token account and fees.
- The first wallet in the bundle also pays the [Jito tip](https://vortexdeployer.com/docs/other/glossary#jito-tip).
- A wallet that cannot pay its full amount buys what it can. A wallet that cannot pay at all is left out.

## Set up Bundle on a live token

1. Open the token in the [terminal](https://vortexdeployer.com/docs/other/glossary#terminal). In **Tasks**, press **New task**.
2. Under **Task type**, pick **Bundle**.
3. Pick the wallets, and type each wallet's amount under **Per-wallet SOL**.
4. Read the check under the wallet list (see below). Fix anything it asks for.
5. Press **Create task**, then **Start**.

![The Bundle form: SOL per wallet and the wallets](https://vortexdeployer.com/docs/tasks/bundle.png)

There is no **Preview** for this task.

## The wallet check

Under the wallet list, the app checks whether your wallets fit in one bundle. It first shows **Checking wallet capacity...**, then one of these:

- **"N wallets / T transactions. No lookup table needed."** — all set.
- **"Platform lookup table selected."** or **"Your lookup table selected."** — the wallets fit with the help of a [lookup table](https://vortexdeployer.com/docs/other/glossary#lookup-table).
- **"N wallets need more accounts added to your lookup table."** — press **Extend lookup table**.
- **"N wallets need a token-specific lookup table."** — press **Prepare lookup table**.
- **"This selection does not fit. Keep at most N of these wallets, in this order."** — remove wallets until it fits.

Making or growing a lookup table costs a little SOL in [rent](https://vortexdeployer.com/docs/other/glossary#rent) and fees, paid by a selected wallet. If none has enough, you see **Fund a selected wallet for table rent and fees**. Add SOL, then press **Retry check**.

The check confirms that the amounts fit. It does not check that each wallet has the SOL.

## How many wallets

- Up to 10 wallets in the default mode.
- Up to 24 wallets in **Buy (ATAs pre-made)** mode, once their token accounts exist.
- Fewer, if the wallets have never bought this token. The check tells you the exact number.

## Bundle at a launch

You can add Bundle on the Tasks step of the launch wizard. With **Auto-start at launch** on, it reads **included in the atomic launch bundle**. The token is made and your wallets buy in the same bundle. If the bundle does not land, the token is not made either.

- A bundle that rides the launch must use the default **Mode**.
- It takes 4 to 8 wallets, depending on the lookup table.
- Tick **Allow automatic lookup-table setup** for up to 20 buyers. The dev wallet then pays the table's rent and fees, up to the amount shown. The table is set up before you press **Create**. If you never launch, it is closed after a day and the rent goes back to the dev wallet.

See [Tasks step](https://vortexdeployer.com/docs/launch/tasks-step).

## Key settings

- **Per-wallet SOL** — the SOL each wallet spends.

Under **Advanced**:

- **Mode** — **Buy and set up token accounts** (the default), **Set up token accounts only**, or **Buy (ATAs pre-made)**. ATAs are token accounts. Setting up the [token accounts](https://vortexdeployer.com/docs/other/glossary#token-account) first lets more wallets fit in the later buy.
- **Token accounts per transaction** — only in **Set up token accounts only**. Default 8, up to 12.
- **Jito tip** — the default, 1,000,000, is 0.001 SOL.
- **Slippage** — default 500 [basis points](https://vortexdeployer.com/docs/other/glossary#bps) (5%).
- **Pre-swap slippage** — only for a token priced in a stock or USDC. The task first swaps each wallet's SOL into that asset. If the bundle fails, it swaps it back to SOL. Default 100 basis points (1%).
- **Fire if already live** — on by default. The bundle fires at once if the token already trades. When off, it waits until the token's pool next changes, for example at the launch or the next trade.
- **Max wait** — how long to wait for the token to go live. 0 (the default) waits with no limit. At the limit, the task ends without buying.
- **Confirmation time limit** — how long to wait for the bundle to land.

:::warning All buys are real and land together
Every wallet buys at the same moment with real SOL. Each buy pays the [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee) and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee), and the first wallet pays the tip. Many buys in one block move the price a lot, so the last wallet in the bundle pays the most per token. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Troubleshooting

- **"no wallet can pay for its buy"** — no wallet has enough SOL. Add SOL and start again.
- **"did not land"** — the bundle did not get in, and nothing was bought. Raise the **Jito tip** and try again.
- **"Select at most N launch bundle buyers"** — at a launch, remove wallets until you are at or below N.

## Every setting

@engine(bundle)

## See also

- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Buy](https://vortexdeployer.com/docs/tasks/buy)
- [Snipe](https://vortexdeployer.com/docs/tasks/snipe)
- [Tasks step](https://vortexdeployer.com/docs/launch/tasks-step)

---

# Hand Switcher

> Move a token from some of your wallets to others, one sell and one matching buy at a time.

Source: https://vortexdeployer.com/docs/tasks/hand-switcher · Markdown: https://vortexdeployer.com/docs/tasks/hand-switcher.md

The Hand Switcher moves a token from one group of your wallets (the sellers) to another group (the buyers). In each round, one seller sells and one buyer buys about the same amount, in the same [bundle](https://vortexdeployer.com/docs/other/glossary#bundle). Use it to spread your tokens over more wallets and add trades to the chart. The price ends each round close to where it started.

## Before you start

- It works on Solana only.
- Seller wallets must hold the token.
- Buyer wallets pay with their own SOL. Each one needs at least **Min buyer SOL** (0.1 SOL by default), plus enough for the buy and its fees. See [Fund wallets](https://vortexdeployer.com/docs/wallets/fund).

## Set it up

1. Open the token's terminal and click **New task** on the **Tasks** panel.
2. Under **Task type**, pick **Hand Switcher**. It is in the **Trade** group.
3. Set **Choose sellers from**: **Custom wallets**, **Role wallets** or **Role + custom**.
   - With custom wallets, tick them under **Seller wallets — sell tokens, receive SOL**.
   - With a [role](https://vortexdeployer.com/docs/other/glossary#role), pick the **Seller role**. Every wallet with that role sells.
4. Set **Choose buyers from** the same way. Custom buyers are ticked under **Buyer wallets — spend SOL, receive tokens**.
5. Set **Spend limit per buy**.
6. Click **Create task**. To start right away, tick **Start immediately** and click **Create & start**.

![The Hand Switcher form: sellers, buyers and the spend limit](https://vortexdeployer.com/docs/tasks/hand-switcher.png)

To add the token's [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet), turn on **Dev wallet sells** or **Dev wallet buys**. The form and the card work as for every task: see [How tasks run](https://vortexdeployer.com/docs/tasks/overview). The card's **Who sells and who buys** section shows both sides.

## How a round works

1. The task picks one seller and one buyer at random.
2. The buyer buys for up to **Spend limit per buy**. It always keeps a little SOL back (the **SOL reserve**).
3. The seller sells the number of tokens that buy should get. If it holds fewer, it sells what it has, and the buy gets smaller to match.
4. Both trades go out together, with a [Jito tip](https://vortexdeployer.com/docs/other/glossary#jito-tip). They land together or not at all.
5. The task waits a random time (1 to 5 seconds by default) and starts the next round.

Before each round, the task prices both trades. If the buy would cost more than twice the **Slippage** above what the sell brings back, it tries a smaller round. If that still costs too much, it tries another pair of wallets and sends nothing for this one.

It runs until no seller holds tokens or no buyer has enough SOL, or until you press **Stop**. A wallet on both sides only sells. A wallet that gets the role later joins in.

## Settings that matter

- **Spend limit per buy** — the most one buyer spends in one round. Default 0.05 SOL. Not a total budget; fees come on top.
- **Wait between trades** (Advanced) — the pause between rounds, picked at random between the two numbers. Default 1,000–5,000 ms.
- **SOL reserve** (Advanced) — SOL each buyer keeps back. Default 0.03–0.1 SOL.
- **Min buyer SOL** (Advanced) — a buyer with less SOL than this sits out. Default 0.1 SOL.
- **Jito tip** (Advanced) — paid once every round. Default 0.001 SOL.
- **Max supply per wallet** (Advanced) — a buyer that already holds this share of the [supply](https://vortexdeployer.com/docs/other/glossary#supply) sits out. 0 = off.
- **Stop after repeated errors** (Advanced) — the task fails after this many errors in a row. Default 10.

:::warning Every round costs money
Each round is two real trades. Together they pay the Jito tip, network fees, the [pool](https://vortexdeployer.com/docs/other/glossary#pool)'s trading fee on both sides, the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee) and some [price impact](https://vortexdeployer.com/docs/other/glossary#price-impact). Over many rounds this adds up. Trades that landed cannot be undone. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::warning Not right after a launch
In the first seconds after a launch the price moves very fast. A round can then sell clearly more tokens than its buy gets back, and the difference stays in the pool. Let the first rush of trading pass before you start a Hand Switcher.
:::

## All settings

@engine(handswitcher)

## Troubleshooting

- **"no seller wallet holds this token"** — pick sellers that hold it.
- **"no eligible buyer"** — every buyer has less than **Min buyer SOL**, or already holds **Max supply per wallet**. Add SOL to the buyers or lower the setting.
- **"all eligible wallet pairs exceed the cost limit"** — the pool is too thin for these rounds. Lower **Spend limit per buy**, or wait for more trading.
- **"no tradeable pool for this mint"** — the token has no pool the task can trade yet.

## See also

- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Fund wallets](https://vortexdeployer.com/docs/wallets/fund)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)

---

# Token Sender

> Send a token from your wallets to new or existing wallets, a random share of the supply each.

Source: https://vortexdeployer.com/docs/tasks/token-sender · Markdown: https://vortexdeployer.com/docs/tasks/token-sender.md

The Token Sender takes a token from some of your wallets and spreads it over other wallets. Each receiving wallet gets a random share of the token's total [supply](https://vortexdeployer.com/docs/other/glossary#supply), between a minimum and a maximum you set. Use it to split a large holding into many smaller ones. It sends tokens directly; it does not buy or sell.

## Before you start

- The wallets you send from must hold the token.
- One wallet pays for the transfers: the **Funding wallet**. On Solana it pays network fees, the SOL for each new wallet and the [rent](https://vortexdeployer.com/docs/other/glossary#rent) for each new [token account](https://vortexdeployer.com/docs/other/glossary#token-account). Make sure it has enough SOL.

## Set it up

1. Open the token's terminal and click **New task** on the **Tasks** panel.
2. Under **Task type**, pick **Token Sender**. It is in the **Distribute** group.
3. Pick **Destinations**:
   - **Auto-create** — makes as many new wallets as the tokens allow.
   - **Set count** — makes up to **Wallet count** new wallets (4 by default).
   - **Existing wallets** — sends to wallets you already have. Pick them under **Receive tokens in**.
4. Set **Per wallet**: the smallest and largest share each wallet gets, in % of supply. Default 1–2 %.
5. For new wallets, set **Fund each new wallet**: the SOL each one gets so it can trade later. Default 0.01 SOL.
6. Choose a **Funding wallet**, or leave it on **Automatic · first eligible source** to use the first sending wallet.
7. In the wallet list, tick the wallets to send _from_.
8. Click **Create task**. On the new card, open **Preview** to see the plan and whether the funding wallet has enough. Then click **Start**.

![The Token Sender form: destinations, the share per wallet and the funding wallet](https://vortexdeployer.com/docs/tasks/token-sender.png)

The form and the card work the same for every task: see [How tasks run](https://vortexdeployer.com/docs/tasks/overview).

## What happens

- With **Auto-create**, each sending wallet keeps sending until what it has left is less than the minimum share. So almost all the tokens in those wallets move.
- With **Set count** or **Existing wallets**, the task stops early when the tokens run out.
- Tokens go out in small groups, a few wallets per transaction: **Batch size**, 3 by default, up to 6. Groups are 500 ms apart (**Delay between batches**).
- New wallets are saved in your [Wallets](https://vortexdeployer.com/docs/wallets/overview) with the Trading role. You hold their keys, like any other wallet.
- **Auto-create** stops with an error if it would need more than 500 new wallets. Raise **Per wallet** to need fewer.

## What it costs

- No [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee): sending tokens is not a trade.
- Network fees for every transaction.
- For each new wallet: the **Fund each new wallet** amount, plus about 0.002 SOL of rent for its token account.
- On Robinhood, **Fund each new wallet** is in ETH (0.0005 by default), and each sending wallet pays the gas for its own transfers.

:::warning Transfers cannot be undone
Tokens that arrive in a wallet stay there. The task cannot pull them back. To move them again, you need another Token Sender or a sell. The SOL sent to new wallets is still yours: get it back with [Collect funds](https://vortexdeployer.com/docs/wallets/collect). See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::tip Check before you start
Open **Preview** on the card first. It sends nothing. It shows how many wallets the plan creates, how many tokens each gets, and how much SOL the funding wallet needs.
:::

## All settings

@engine(tokendisperser)

## Troubleshooting

- **"Token Sender needs more than 500 fresh wallets"** — your share per wallet is too small for the amount you hold. Raise **Per wallet**.
- **The task sent to fewer wallets than you set** — the sending wallets ran out of tokens. Lower **Per wallet** or add a sending wallet that holds more.

## See also

- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Collect funds](https://vortexdeployer.com/docs/wallets/collect)
- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)

---

# Mixer

> Fund or empty your wallets through an exchange, so the chain shows no direct link between them.

Source: https://vortexdeployer.com/docs/tasks/mixer · Markdown: https://vortexdeployer.com/docs/tasks/mixer.md

A [mixer](https://vortexdeployer.com/docs/other/glossary#mixer) moves SOL through an exchange instead of straight from wallet to wallet. You pay into an order at [Husher](https://vortexdeployer.com/docs/other/glossary#husher), an outside service. An exchange (such as Binance) then pays each wallet from its own funds, after a wait you choose. On the chain, your wallets show no direct transfer between them.

There are two ways to use it:

- **Fund** — one payment fills many wallets. It is one Husher order.
- **Collect** — many wallets empty into one address. Each wallet gets its own Husher order.

Both start from the **Wallets** page and run as a Mixer task.

## Fund wallets through the Mixer

1. On **Wallets**, tick the wallets you want to fund.
2. In the actions panel, under **Funds**, click **Fund**. The **Fund wallets** window opens.
3. Under **Method**, pick **Mixer**.
4. On **Amount and wallets**, enter the total. Pick a **Distribution**: **Equal**, **Custom** or **Variation**.
5. Under **Fund from**, pick one of your wallets, or **Deposit address · pay from anywhere** to pay from outside. A wallet you fund cannot also be the source.
6. Click **Next — exchanges & holds**. For each wallet, pick the exchange and the **Hold (minutes)**: how long the exchange waits before it pays that wallet. **Randomize exchanges** and **Auto-distribute holds** fill these in for you.
7. Click **Create order** (from your wallet) or **Create order — get deposit address**.
8. If you chose the deposit address, send exactly the amount shown under **Send exactly** to the **Husher deposit address**.

![The Fund wallets window with Method set to Mixer](https://vortexdeployer.com/docs/tasks/mixer.png)

The last step lists every wallet with its exchange, hold, status and payout. **Execute now** skips one wallet's hold and pays it out right away. You can close or minimize the window: the task keeps running. A minimized window comes back from the bottom bar.

For the whole window, see [Fund wallets](https://vortexdeployer.com/docs/wallets/fund).

## Collect through the Mixer

1. On **Wallets**, tick the wallets you want to empty.
2. Under **Funds**, click **Collect**. The **Collect funds** window opens.
3. Under **Method**, pick **Mixer**.
4. Pick the **Exchange**.
5. Enter the **Destination wallet**, or click **Use one of my wallets**.
6. Click **Collect via Mixer**, check the summary, and click **Collect now**.

Each wallet sends its SOL into its own Husher order, and the exchange pays the destination. Under **Advanced**, **Delayed collection** gives every order a random hold in a range you set. See [Collect funds](https://vortexdeployer.com/docs/wallets/collect).

## Limits

- Each wallet must get at least 0.15 SOL when you fund (0.01 ETH on Robinhood). When you collect, wallets with less than 0.15 SOL are skipped.
- Exchanges on Solana: **Binance** (default), **KuCoin**, **Bitget**. On Robinhood: **Husher** (default), **KuCoin**, **ChangeNOW**, **SideShift**.
- Collecting through the Mixer works on Solana only. Funding works on Solana and Robinhood.
- A hold can be 0 to 1,440 minutes (one day).
- The task follows the orders for 4 hours by default (**Watch for**). Husher keeps working on them after that.

## What it costs

There is no [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee) on Mixer orders. Husher's fee comes out of each payment, so each wallet receives a bit less than its share. The amounts the window shows are before that fee. Network fees apply to the payments you send.

:::danger Payments cannot be undone
Once SOL reaches a Husher [deposit address](https://vortexdeployer.com/docs/other/glossary#deposit-address), you cannot cancel it from here. Send exactly the amount shown, to the address shown, on the right chain. Double-check a collect destination: a wrong address loses the funds. Never collect straight to an exchange deposit address. Send to a wallet you control first. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::info If nothing arrives
If no payment reaches the deposit address in time, the task stops with a time-out. Its **Deposit** section then says _Nothing moved_. The address still belongs to the task: pay it, then press **Start** on the task to go on. **Run again** on a Mixer only pays wallets that have not been paid yet. See [How tasks run](https://vortexdeployer.com/docs/tasks/overview).
:::

## All settings

These are the task's own settings, as **Edit** shows them on its card. The Fund and Collect windows set them for you.

@engine(mixer)

## See also

- [Fund wallets](https://vortexdeployer.com/docs/wallets/fund)
- [Collect funds](https://vortexdeployer.com/docs/wallets/collect)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)

---

# Wallet warm-up task

> How a warm-up run trades, what it costs, and every setting of the task.

Source: https://vortexdeployer.com/docs/tasks/wallet-warmup · Markdown: https://vortexdeployer.com/docs/tasks/wallet-warmup.md

A [warm-up](https://vortexdeployer.com/docs/other/glossary#warm-up) gives fresh wallets a trading history. Each wallet makes a few small real trades: it buys a coin, holds it for a short time, then sells it all. Use it before you put new wallets to work, so they do not look brand new. This page explains the task in detail. For the short version, see [Wallet warm-up](https://vortexdeployer.com/docs/wallets/warm-up).

## Start a warm-up

You can start it from two places:

- **Wallets** page: tick the wallets, then click **Warm up** under **Acquire**.
- A token's terminal: click the flame button **Warm up wallets** on the **Tasks** panel. The warm-up then trades that token only.

![The Warm up wallets window opened from the terminal](https://vortexdeployer.com/docs/tasks/wallet-warmup.png)

Then fill in the **Warm up wallets** window and press **Start warmup**. The steps are on [Wallet warm-up](https://vortexdeployer.com/docs/wallets/warm-up#warm-up-wallets). The task starts as soon as you confirm.

Warm-ups that are already running show under **Running warmups**. Click one to open its task card.

## How a run works

- A run is made of cycles. Each cycle makes **Trades per cycle** buys in total, spread over about 10 minutes.
- The wallets take turns, one buy each. If you pick more wallets than trades per cycle, some wallets wait for the next cycle.
- Each buy is held for a random time inside **Hold time (seconds)**, then fully sold.
- After a cycle, the task waits (one hour by default), then starts the next one. It stops after **Cycles (0 = until stopped)** cycles.
- With **Auto**, each buy takes a different live [pump.fun](https://vortexdeployer.com/docs/other/glossary#pump-fun) coin. A wallet never warms the same coin twice, and two wallets never hold the same coin at once. It only picks coins still under 1.5 times their launch price. If no coin fits, that turn is skipped. On Robinhood it uses new pons coins instead.

## Settings

- **Buy per wallet (SOL)** — the size of each buy, picked at random in this range. Default 0.01–0.05 SOL. It is per buy, not a total.
- **Hold time (seconds)** — how long each buy is held before the sell. Default 30–120.
- **Trades per cycle** — buys per cycle, across all the wallets together. Default 5.
- **Cycles (0 = until stopped)** — how many cycles to run. Default 1. With 0 it runs until you stop it.
- **Stop-loss (%)** (Advanced) — sells a held coin early if it falls this far below what it cost. Default 20. 0 = off.
- **Look like trading bots** (Advanced) — tags each wallet's trades as one of these trading apps: **Photon**, **Trojan**, **BullX**, **Axiom** or **Axiom (2nd fee wallet)**. Each tagged trade sends a tiny 0.00000001 SOL.

:::warning Real trades, real losses
Every buy spends real SOL and every sell is a real trade. Each one pays network fees, the pool's trading fee and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee). The coins are brand new and can drop fast, so many sells bring back less than the buy cost. Plan to lose a little on each trade. Trades that landed cannot be undone. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::tip Keep SOL in every wallet
A wallet needs enough SOL for its biggest buy plus fees. Fund the wallets first: see [Fund wallets](https://vortexdeployer.com/docs/wallets/fund).
:::

## All settings

These are the task's own settings, as **Edit** shows them on its card. The window above sets the main ones; the others keep their defaults.

@engine(warmup)

## See also

- [Wallet warm-up](https://vortexdeployer.com/docs/wallets/warm-up)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)
- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)

---

# Limit order

> Buy or sell once, when the market cap reaches a level you pick.

Source: https://vortexdeployer.com/docs/tasks/limit-order · Markdown: https://vortexdeployer.com/docs/tasks/limit-order.md

A [limit order](https://vortexdeployer.com/docs/other/glossary#limit-order) waits until the price reaches a number you pick, then buys or sells. Here the number is the token's [market cap](https://vortexdeployer.com/docs/other/glossary#market-cap) in US dollars. It trades once and then it is done.

Use it to:

- sell when the market cap rises above a goal (a [take profit](https://vortexdeployer.com/docs/other/glossary#take-profit));
- sell when it falls below a floor (a [stop-loss](https://vortexdeployer.com/docs/other/glossary#stop-loss));
- buy when it drops to a lower level.

## Set it up

1. Open the token's terminal and click **New task** on the **Tasks** panel.
2. Under **Task type**, pick **Limit order**. It is in the **Automate** group.
3. Choose **Buy or sell**. The default is **Sell**.
4. Enter the **Market cap level** in USD.
5. Set **Trade when the target**: **rises above the level** or **falls below the level**.
6. Choose the **Amount type** and the **Amount per trade** (see below).
7. Under **Wallets**, pick **All wallets**, **By role** or **Choose wallets**.
8. Click **Create task**, or tick **Start immediately** and click **Create & start**.

![The Limit order form: the market cap level and what to trade](https://vortexdeployer.com/docs/tasks/limit-order.png)

The form and the card work the same for every task: see [How tasks run](https://vortexdeployer.com/docs/tasks/overview). While it waits, the card's **Orders** section shows the order and the live market cap.

## Settings that matter

- **Amount type** — what **Amount per trade** means. For a buy: **SOL per wallet** or **% of wallet balance**. For a sell: **% of tokens held** or **% of supply**.
- **Amount per trade** — the amount for each wallet. A percentage cannot go above 100.
- **Wallets** — **All wallets** uses every wallet of this token, **By role** every wallet with the roles you tick. Both include wallets added before the order fires. Sells skip wallets with no tokens. The [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet) stays out unless you turn on its switch.
- **Wallets to use** — which of the chosen wallets trade when the order fires. The default, **Every wallet**, uses all of them. **Take turns**, **Random wallet**, **Biggest holder**, **Smallest holder** and **Richest wallet** each use only one.
- **Start delay** and **Run for** (Advanced) — wait before the order starts watching, and stop watching after a while. Empty **Run for** = wait until it fires.
- **Slippage** (Advanced) — how far the fill may move from the quote. Default 500 (5 %).


:::warning It can fire the moment you start it
The order checks a level, not a crossing. If the market cap is already past your level when the task starts, it trades right away. For example, a sell that waits for "rises above $50,000" sells at once when the market cap is already $60,000. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::warning The fill is not exactly your level
When the level is reached, the task sends a normal market trade. On a fast-moving token the price can be past your level by the time it lands, within your **Slippage**. Every trade pays network fees and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee), and it cannot be undone.
:::

## All settings

@engine(limit_order)

## Troubleshooting

- **The order never fires** — check **Trade when the target**: "rises above" for a goal higher than now, "falls below" for a lower one. Check that the chosen wallets hold the token (sell) or SOL (buy).
- **"No routable pool"** — the task cannot find a pool to price the token. It fails instead of guessing.
- **"… of … wallet trades confirmed; remaining trades failed or need reconciliation"** — some wallets traded and some did not. The task stops. Check the wallets' balances before you start it again, so the ones that already traded do not trade twice.

## See also

- [Ladder](https://vortexdeployer.com/docs/tasks/ladder) — many limit orders at once
- [Trailing stop](https://vortexdeployer.com/docs/tasks/trailing-stop) — a stop that follows the price up
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)

---

# Ladder

> Spread a buy or sell over several market cap levels instead of one.

Source: https://vortexdeployer.com/docs/tasks/ladder · Markdown: https://vortexdeployer.com/docs/tasks/ladder.md

A [ladder](https://vortexdeployer.com/docs/other/glossary#ladder) is a row of [limit orders](https://vortexdeployer.com/docs/other/glossary#limit-order) at evenly spread levels. A sell ladder sells a part at each level as the [market cap](https://vortexdeployer.com/docs/other/glossary#market-cap) rises. A buy ladder buys a part at each level as it falls. You take profit, or build a position, step by step instead of all at once.

## Set it up

1. Open the token's terminal and click **New task** on the **Tasks** panel.
2. Under **Task type**, pick **Ladder**. It is in the **Automate** group.
3. Choose **Buy or sell**. The default is **Sell**.
4. Enter **From (market cap)** and **To (market cap)** in USD.
5. Set **Number of orders**: how many levels from the first to the last, both included. Default 4, at least 2.
6. For market cap levels, pick the **Spacing**: **Even dollars** or **Same % step**.
7. Choose the **Amount type** and the **Amount per order**.
8. Pick **Wallets to use**, then tick the wallets in the list.
9. Click **Create task**, or tick **Start immediately** and click **Create & start**.

![The Ladder form: the market cap range, the number of orders and the amounts](https://vortexdeployer.com/docs/tasks/ladder.png)

The form and the card work the same for every task: see [How tasks run](https://vortexdeployer.com/docs/tasks/overview). The card's **Orders** section lists every level, its state and the live market cap.

## How the levels work

- A **sell** ladder sells when the market cap rises above each level. A **buy** ladder buys when it falls below each one.
- Each level trades once.
- **Even dollars** puts the same dollar gap between levels. From $100,000 to $400,000 with 4 orders gives $100k, $200k, $300k and $400k.
- **Same % step** puts the same percentage gap between levels. From $100,000 to $800,000 with 4 orders gives $100k, $200k, $400k and $800k.
- The task ends when every level has traded, or when **Run for** (Advanced) runs out.

## Settings that matter

- **Amount type** — for a buy: **SOL per wallet** or **% of wallet balance**. For a sell: **% of tokens held** or **% of supply**.
- **Amount per order** — the amount for each wallet at each level.
- **Wallets to use** — the default, **Take turns**, uses _one_ wallet per level, the next one each time. **Every wallet** makes all the ticked wallets trade at every level.
- **Slippage** (Advanced) — how far a fill may move from the quote. Default 500 (5 %).

:::tip Selling a share at each level
With **% of tokens held**, each level sells that share of what the wallet holds at that moment. It is not a share of what it held at the start. So one wallet selling 25 % at each of 4 levels still keeps about a third of its tokens at the end.
:::

:::warning Levels already passed fire at once
Each level checks where the market cap is now. If you start a sell ladder from $100,000 while the market cap is $250,000, the $100k and $200k levels sell right away. A buy ladder does the same with levels above the market cap. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::warning Real trades
Each level is a real trade. It pays network fees and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee), may fill a little past its level (within your **Slippage**), and cannot be undone.
:::

## All settings

@engine(ladder)

## See also

- [Limit order](https://vortexdeployer.com/docs/tasks/limit-order)
- [Trailing stop](https://vortexdeployer.com/docs/tasks/trailing-stop)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)

---

# Mirror

> Answer other traders on your token — sell when they buy, or buy when they sell.

Source: https://vortexdeployer.com/docs/tasks/mirror · Markdown: https://vortexdeployer.com/docs/tasks/mirror.md

[Mirror](https://vortexdeployer.com/docs/other/glossary#mirror) watches other people's trades on your token and answers each one. When someone buys, your wallets sell. Or, the other way round, when someone sells, your wallets buy. Use it to sell into real demand a little at a time, or to soak up sells and steady the price.

## Set it up

1. Open the token's terminal and click **New task** on the **Tasks** panel.
2. Under **Task type**, pick **Mirror**. It is in the **Automate** group.
3. Set **Your wallets**: **Sell when others buy** (the default) or **Buy when others sell**.
4. Choose the **Amount type** and the **Amount per trade** (see below).
5. Pick **Wallets to use**, then tick the wallets in the list.
6. Set limits: a **Market cap** range, a **Budget** (buys only) and **Maximum trade rounds**. All three are optional, but set at least one.
7. Click **Create task**, or tick **Start immediately** and click **Create & start**.

![The Mirror form: which side your wallets take and how much they answer](https://vortexdeployer.com/docs/tasks/mirror.png)

The form and the card work the same for every task: see [How tasks run](https://vortexdeployer.com/docs/tasks/overview). The card's **Orders** section shows the task and the live [market cap](https://vortexdeployer.com/docs/other/glossary#market-cap).

## How it answers

- Only trades by other people count. Your own wallets are always ignored, and you can add more addresses to ignore.
- **% of the trade** sizes your answer from their trade. At 100 %, if someone buys 1 million tokens, a wallet sells 1 million tokens. If someone sells for 0.5 SOL, a wallet buys for 0.5 SOL. A wallet never trades more than it holds or can spend.
- Mirror waits a tenth of a second before it answers. If the trade is reversed in that time by one of about the same size, it does not answer. This skips most bots that buy and sell back at once.
- It keeps answering until you stop it, or until it reaches the **Budget**, the **Maximum trade rounds** or the **Run for** time.

## Settings that matter

- **Amount type** — the default is **% of the trade**. You can also pick a fixed size. For buys: **SOL per wallet** or **% of wallet balance**. For sells: **% of tokens held** or **% of supply**.
- **Amount per trade** — default 100 (%).
- **Wallets to use** — the default, **Take turns**, answers each trade with _one_ wallet, the next one each time. **Every wallet** answers with all of them, each with the full amount.
- **Market cap** — trade only between a **Minimum market cap** and a **Maximum market cap** in USD. Empty = no limit.
- **Budget** — the most SOL the buys may spend in total. Empty = no limit. It does not limit sells.
- **Maximum trade rounds** — stop after this many answers. Empty = no limit.
- **Trades to respond to** (Advanced) — the share of trades to answer; the rest are skipped at random. Default 100 %.
- **Combine trades below** (Advanced) — for buys: save up small answers and buy once their total reaches this many SOL. 0 = answer each trade. It has no effect on sells.
- **Ignore traders (addresses)** (Advanced) — wallets whose trades Mirror should not answer.

:::warning It can run through a lot of money
With no limits, a buying Mirror buys into every sell, even a long dump. A selling Mirror can sell all your tokens into a buying rush. Before you start, give a buying Mirror a **Budget**. On either side, a **Market cap** range or **Maximum trade rounds** also sets a limit. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::warning Every answer is a real trade
Each answer pays network fees and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee), and fills at the market price within your **Slippage**. Many small answers cost more in fees than a few large ones. Trades that landed cannot be undone.
:::

## All settings

@engine(mirror)

## See also

- [DCA](https://vortexdeployer.com/docs/tasks/dca)
- [Limit order](https://vortexdeployer.com/docs/tasks/limit-order)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)

---

# DCA

> Buy or sell the same amount of a token on a timer, bit by bit.

Source: https://vortexdeployer.com/docs/tasks/dca · Markdown: https://vortexdeployer.com/docs/tasks/dca.md

[DCA](https://vortexdeployer.com/docs/other/glossary#dca) (dollar-cost averaging) buys or sells a fixed amount on a timer. You build or reduce a position bit by bit. No single trade moves the price much, and you get an average price over time.

## Set it up

1. Open the token's terminal and click **New task** on the **Tasks** panel.
2. Under **Task type**, pick **DCA**. It is in the **Automate** group.
3. Choose **Buy or sell**. The default is **Buy**.
4. Set **Time between trades** in seconds. Default 60.
5. Choose the **Amount type** and the **Amount per trade**.
6. Pick **Wallets to use**, then tick the wallets in the list.
7. Set limits: a **Market cap** range, a **Budget** (buys only), **Maximum trade rounds** or **Run for**. All are optional, but without one it runs until you stop it.
8. Click **Create task**, or tick **Start immediately** and click **Create & start**.

![The DCA form: buy or sell, the time between trades and the amount per trade](https://vortexdeployer.com/docs/tasks/dca.png)

The form and the card work the same for every task: see [How tasks run](https://vortexdeployer.com/docs/tasks/overview).

## How it runs

- The first trade comes one interval after the start, then one every interval.
- With **Timing variation** (Advanced), each wait is randomly shorter or longer by up to that many seconds. The wait is never under 1 second.
- Outside your **Market cap** range, a round is skipped and the timer keeps going.
- If no chosen wallet can trade (no SOL to buy, no tokens to sell), that round does nothing.
- It ends when you stop it, or when it reaches the **Budget**, the **Maximum trade rounds** or the **Run for** time.

## Settings that matter

- **Amount type** — for a buy: **SOL per wallet** or **% of wallet balance**. For a sell: **% of tokens held** or **% of supply**.
- **Amount per trade** — the amount for each wallet on every trade. Default 0.1. A percentage cannot go above 100.
- **Wallets to use** — the default, **Take turns**, trades with _one_ wallet each round, the next one each time. **Every wallet** makes all of them trade every round.
- **Minimum market cap** and **Maximum market cap** — trade only inside this range, in USD. Empty = no limit.
- **Budget** — the most SOL the buys may spend in total. Empty = no limit. It does not limit sells.
- **Maximum trade rounds** — stop after this many rounds.
- **Slippage** (Advanced) — how far a fill may move from the quote. Default 500 (5 %).

:::tip A sell DCA slows down by itself
With **% of tokens held**, each sell takes that share of what the wallet holds _now_. So, below 100 %, each sell is smaller than the last. To sell the same number of tokens each time, use **% of supply**.
:::

:::warning Real trades, on a timer
Every round is a real trade. It pays network fees and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee), and it cannot be undone. A short interval with no limit can spend a lot: 0.1 SOL every 60 seconds is 6 SOL an hour, and more with **Every wallet**. Set a **Budget** before you start a buy DCA. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## All settings

@engine(dca)

## See also

- [Limit order](https://vortexdeployer.com/docs/tasks/limit-order)
- [Mirror](https://vortexdeployer.com/docs/tasks/mirror)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)

---

# Trailing stop

> Follow the market cap up and sell once it drops a set percentage from its highest point.

Source: https://vortexdeployer.com/docs/tasks/trailing-stop · Markdown: https://vortexdeployer.com/docs/tasks/trailing-stop.md

A [trailing stop](https://vortexdeployer.com/docs/other/glossary#trailing-stop) follows the [market cap](https://vortexdeployer.com/docs/other/glossary#market-cap) up and sells when it drops a set percentage from its highest point. While the price climbs, your sell level climbs with it. When the price turns and falls far enough, the task sells. You keep most of a rise without guessing the top.

## Set it up

1. Open the token's terminal and click **New task** on the **Tasks** panel.
2. Under **Task type**, pick **Trailing stop**. It is in the **Automate** group. It only sells.
3. Set **Drop from peak** in %. Default 20.
4. Optional: set **Start tracking above market cap** in USD.
5. Choose the **Amount type** and the **Amount per trade**.
6. Set **Wallets to use** to **Every wallet** if all the ticked wallets should sell (see the warning below). Then tick the wallets in the list.
7. Click **Create task**, or tick **Start immediately** and click **Create & start**.

![The Trailing stop form: the drop from the peak and the amount to sell](https://vortexdeployer.com/docs/tasks/trailing-stop.png)

The form and the card work the same for every task: see [How tasks run](https://vortexdeployer.com/docs/tasks/overview). The card's **Orders** section shows the live market cap while the task waits.

## How it works

- The task keeps the highest market cap it has seen since it started: the peak.
- When the market cap falls **Drop from peak** % below that peak, it sells once and the task ends.
- Example: with 20 %, the market cap climbs from $80,000 to a peak of $150,000. It sells when the market cap falls to $120,000 or lower.
- With **Start tracking above market cap**, nothing sells until the peak has reached that number. Use it to wait for a rise before the stop counts.
- The first check never sells. The peak starts at the market cap when the task starts.

## Settings that matter

- **Drop from peak** — how far below the peak, in %, the task sells. From 0.1 to 99. A small number sells on a small dip. A large one gives the price more room but sells lower.
- **Amount type** — **% of tokens held** (the default) or **% of supply**.
- **Amount per trade** — the amount for each wallet. Default 100, which sells everything each wallet holds.
- **Wallets to use** — which of the ticked wallets sell. The default is **Take turns**.
- **Minimum market cap** and **Maximum market cap** — only watch inside this range, in USD. Empty = no limit.
- The [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet) stays out unless you turn on **Sell from the dev wallet**.

:::warning The default sells from one wallet only
The task sells once and ends. With the default **Take turns**, that one sell uses _one_ wallet: the next in turn. The other wallets keep their tokens. To sell from all the ticked wallets, set **Wallets to use** to **Every wallet**. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::warning The sell is not exactly your level
When the drop is reached, the task sends a normal market trade. In a fast fall the price can be lower by the time it lands, within your **Slippage**. The trade pays network fees and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee), and it cannot be undone.
:::

## All settings

@engine(trailing_stop)

## Troubleshooting

- **"… of … wallet trades confirmed; remaining trades failed or need reconciliation"** — some wallets traded and some did not. The task stops. Check the wallets' balances before you start it again, so the ones that already traded do not trade twice.

## See also

- [Limit order](https://vortexdeployer.com/docs/tasks/limit-order) — sell at a fixed level
- [Ladder](https://vortexdeployer.com/docs/tasks/ladder)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)

---

# Scheduled launch

> Set up a launch now and let it create the token on its own at a time you pick.

Source: https://vortexdeployer.com/docs/tasks/scheduled-launch · Markdown: https://vortexdeployer.com/docs/tasks/scheduled-launch.md

A scheduled launch is a launch you set up now that [mints](https://vortexdeployer.com/docs/other/glossary#mint) the token later, at a time you pick. You do not need to be online when it fires. Behind the scenes it is a task. It waits for the time, then runs the launch as if you had clicked it yourself.

## Schedule a launch

1. Set up the launch in the create wizard as usual: see [Create a project](https://vortexdeployer.com/docs/launch/create-project).
2. On the last step, **Review & Deploy**, pick a date and time under **Launch at**. It uses your own time zone. It must be at least 30 seconds and at most 30 days away.
3. The main button now says **Schedule** instead of **Create**. Click it.
4. A message confirms it: _Launch scheduled for_ followed by the time and the task number. The wizard closes.

![Launch at on the Review & Deploy step](https://vortexdeployer.com/docs/tasks/scheduled-launch.png)

The project stays a [draft](https://vortexdeployer.com/docs/other/glossary#draft) on the **Projects** page until the time comes. Its tile shows a clock and the launch time. Leave **Launch at** empty, or click the **X** beside it (**Mint now instead**), to launch right away.

## What happens at launch time

- It runs the same launch as the **Create** button: the same [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet), dev buy, wallets and tasks, and the same fees.
- With **Launches** above 1, it mints that many tokens, one after another, as a normal launch would.
- It mints once. After that the project shows its token like any other launch.
- If the launch fails at that moment, the task stops with an error and the draft stays.

## Change or cancel it

- To cancel, click **Cancel schedule** on the project's tile. A message says _Scheduled launch cancelled; draft kept_. Nothing is minted.
- To change it, cancel first. Then open the draft, make your changes and schedule it again.

:::warning Changes after scheduling are not used
The launch is saved as it was when you clicked **Schedule**: name, picture, wallets, amounts and tasks. Edits you make to the draft later do not change it. Cancel and schedule again instead. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

:::warning Keep the funds in place
The SOL is checked when the launch fires, not when you schedule it. If you move funds out of the dev wallet or the buyer wallets in the meantime, the launch can fail or buy less. A launch spends real SOL and cannot be undone once the token is minted.
:::

:::info A missed time is never made up
If the launch cannot start within 10 minutes of its time (for example, the service was down), it is cancelled with an error. It never mints late. Schedule it again.
:::

## All settings

@engine(scheduled_launch)

## Troubleshooting

- **"missed its window"** — the time passed by more than 10 minutes before it could run. Nothing was minted. Schedule it again.
- **"this task already fired — a launch mints once"** — this schedule already launched. Schedule a new one to mint again.

## See also

- [Create a project](https://vortexdeployer.com/docs/launch/create-project)
- [Tasks step](https://vortexdeployer.com/docs/launch/tasks-step)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)

---

# XID feed

> Watch posts from chosen X accounts as they happen, with sounds and links to any token address they mention.

Source: https://vortexdeployer.com/docs/xid/feed · Markdown: https://vortexdeployer.com/docs/xid/feed.md

The [XID](https://vortexdeployer.com/docs/other/glossary#xid) feed shows posts and other activity from X accounts as it happens. When a post names a token, you can open it in the terminal or launch your own token from the post. Reading the feed spends nothing.

## Open the feed

- **Full page** — press **XID** in the menu at the top.
- **Sidebar** — on a computer, press **XID** in the bar at the bottom of the screen. The feed opens on the right side of any page. See "The sidebar" below.

The page has three views: **Feed**, **Accounts** and **Settings**.

## Read the feed

The newest events are at the top. The feed keeps up to 100. Each post shows:

- the account's picture, name, follower count and @handle,
- the kind of post, such as **Retweet**, **Quote** or **Reply**, and its time,
- the text and up to 4 pictures,
- a **Deploy** button on the right. See [Deploy from XID](https://vortexdeployer.com/docs/xid/deploy).

When a post holds a Solana [contract address](https://vortexdeployer.com/docs/other/glossary#contract-address), the card says **CA detected** and gets a coloured border. The address shows as a chip under the text. Click the chip to open that token in the [terminal](https://vortexdeployer.com/docs/terminal/overview).

Other events show as short cards, such as "Followed Name (@handle)" or a profile change. **Event details** opens the raw details.

## The toolbar

- **Live** — new posts appear as they arrive.
- **Pause feed** / **Resume feed** — stops and starts the feed. While paused, new posts wait. **Show N new** adds them.
- **Paused while you hover** — the feed holds still while your pointer is over it. Move the pointer away to see new posts.
- **Vamp** — copies another token's look. See [Deploy from XID](https://vortexdeployer.com/docs/xid/deploy).

![The top of the feed: Live, Pause feed, Vamp, the stream status and the first posts. Post text and pictures are blurred here.](https://vortexdeployer.com/docs/xid/feed.png)

The rest of the bar shows the number of events shown and accounts on. It also shows when the account list last updated.

## Choose accounts

Open **Accounts**. The list is shared by every user. You can't add an account from this screen.

1. Search by **@handle or name**, or sort by **Newest**, **On first** or **A–Z**.
2. Use the switch on a row to show or hide that account in your feed.
3. Press the pencil on a row to pick its **Event types** and **Notification sound**. The row then shows **Custom**.

**Turn all on** and **Turn all off** change every account that matches your search.

## Settings

Changes save as soon as you make them.

- **Turn on new accounts** — new accounts show in your feed straight away. On by default.
- **Global event filter** — which kinds of events you see: **Posts**, **Following**, **Profile updates**, **OCR**, **Translation**. A personalized account uses its own choice.
- **Pause on hover** — on by default. This setting is for this device only.
- **Sound on every post** — plays a sound for each new post. On by default.
- **Volume** — 50 by default.
- **CA detection** — marks posts that hold a Solana address. On by default. Pick its **Highlight** colour and **Alert sound**.
- **Custom notifications** — type some handles, pick a sound and a border colour, then press **Add notification**.

The **Deploy** settings are on [Deploy from XID](https://vortexdeployer.com/docs/xid/deploy).

Sounds play only for new events that arrive while the feed is open. A group of posts that arrive together plays one sound.

## The sidebar

- Drag its left edge to make it wider or narrower.
- Press Esc or the ✕ to close it.
- **XID Feed** in its head opens the full page. The gear opens **Settings**. The pause button pauses the sidebar.
- It shows the newest 50 events.

While the sidebar is open, it plays the sounds, and the full XID page stays quiet.

## Troubleshooting

- **"No events yet"** — no account is on, or none has posted yet. Turn some on in **Accounts**.
- **No new posts appear** — look for **Paused** or **Paused while you hover** in the toolbar.

## See also

- [Deploy from XID](https://vortexdeployer.com/docs/xid/deploy)
- [The terminal](https://vortexdeployer.com/docs/terminal/overview)
- [KOL tracker](https://vortexdeployer.com/docs/terminal/kol-tracker)

---

# Deploy from XID

> Start a token launch from a post in the XID feed, with its name, ticker, link and picture filled in.

Source: https://vortexdeployer.com/docs/xid/deploy · Markdown: https://vortexdeployer.com/docs/xid/deploy.md

A post in the [XID feed](https://vortexdeployer.com/docs/xid/feed) can become your next token. The deploy shortcuts open the [launch wizard](https://vortexdeployer.com/docs/other/glossary#launch-wizard) with the post's details filled in. Your [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy) preset brings your creator wallet, dev buy and launch tasks. Nothing launches until you press **Create** in the wizard.

:::warning Create spends real money
There is no practice mode. When you press **Create**, the launch is real. It spends SOL (ETH on Robinhood) on fees and on every buy you set up. A launch cannot be undone. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Before you start

Set up your presets in **Settings** → **Quick deploy**: the creator wallet, the dev buy and the launch tasks with their wallets. See [Set up your presets](https://vortexdeployer.com/docs/launch/quick-deploy#set-up-your-presets). The wizard uses the preset you used last.

Then open the XID page, choose **Settings**, and set your **Deploy** defaults. They save as soon as you change them.

- **Double-click deploy** — double-click a word in a post to deploy with it. Off by default.
- **Selection deploy** — select some text to get a deploy button. Off by default.
- **Platform** — the [launchpad](https://vortexdeployer.com/docs/other/glossary#launchpad) the wizard starts on. You can still change it in the wizard. The default is **Pump.fun**. You can also pick **Raydium LaunchLab**, **Bonk**, **Bonkers**, **StonkFun (LaunchLab · stock quote)**, **Bags (Meteora DBC)** or **pons (Robinhood)**.
- **Launch mode** — which task cards the wizard adds. The default is **Dev buy only**. See the list below.
- **After deploy** — **Open the token terminal** (the default) or **Stay on the feed**.

## Deploy from a post

1. Find the post in the feed.
2. Press **Deploy** on the right of the card.
3. The wizard opens with the post's details filled in. Your preset's creator wallet, dev buy and launch tasks are set too.
4. Optional: pick another preset under **Quick deploy preset**. It swaps the launchpad, creator wallet, dev buy and launch tasks. The name, symbol, links and image stay.
5. Check every field and change what you want. Add anything the post did not give, such as a description.
6. Walk through to **Review** and press **Create**.

If the preset has no creator wallet, or a task has no wallets, pick them in the wizard.

![The Create Project wizard opened from a post, with the name, symbol and X link filled in](https://vortexdeployer.com/docs/xid/deploy.png)

The wizard fills in:

- **Name** — the first 3 words of the post, without links, up to 32 characters. With no words, it uses the @handle.
- **Symbol** — the first word, letters and digits only, in capitals, up to 10 characters.
- **X** (under **Links**) — a link to the post.
- **Token image** — the post's first picture, or a video's preview picture.

## Deploy from one word or from selected text

Turn these on in **Settings** first.

- **Double-click deploy** — double-click one word in a post. The word becomes the name and the symbol. Marks like $, # and @ at its start are dropped.
- **Selection deploy** — select up to 32 characters in a post. A **Deploy “your text”** button appears. Press it to use that text for the name and symbol.

## Launch modes

**Launch mode** adds task cards that your preset does not have. You pick their wallets and amounts. A preset task of the same kind wins: with a Snipe task in the preset, **Snipe** adds nothing.

- **Dev buy only** — no task cards. The launch buys only with your [dev buy](https://vortexdeployer.com/docs/other/glossary#dev-buy), if you set one.
- **Bundle** — adds a [Bundle](https://vortexdeployer.com/docs/tasks/bundle) task. On Robinhood it adds a Buy task instead.
- **Snipe** — adds a [Snipe](https://vortexdeployer.com/docs/tasks/snipe) task.
- **Bundle + Snipe** — adds both. On Robinhood it adds only the Buy task.

## Vamp a token

**Vamp** in the feed's toolbar copies another token's look: its name, ticker, description, links and picture.

1. Press **Vamp**.
2. Paste the token's address into **Contract address**.
3. Check what it found, then press **Use this look**.

The wizard opens with that look, your preset and your **Deploy** settings. See [Clone a token](https://vortexdeployer.com/docs/launch/clone-token).

## After the launch

With **Open the token terminal**, the terminal opens on your new token. With **Stay on the feed**, you stay on the feed.

## Troubleshooting

- **"Could not fetch the tweet image — pick one manually"** — the picture could not be loaded. Choose one in the wizard.
- **Nothing happens on double-click** — turn on **Double-click deploy**, and double-click a single word.
- **No creator wallet or launch tasks** — the preset in use has none. Pick another under **Quick deploy preset**, or set one up in **Settings** → **Quick deploy**.
- **A preset task is missing** — the wizard leaves out tasks the launchpad's chain cannot run, such as a Solana task on Robinhood.
- **"Could not add the preset's wallets to the project"** — the task cards are set, but their wallets did not join the project. Add them on the **Wallets** step.

## See also

- [XID feed](https://vortexdeployer.com/docs/xid/feed)
- [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy)
- [Create a project](https://vortexdeployer.com/docs/launch/create-project)
- [Clone a token](https://vortexdeployer.com/docs/launch/clone-token)

---

# Dashboard

> See your balance, your trading results and your tokens on one screen.

Source: https://vortexdeployer.com/docs/account/dashboard · Markdown: https://vortexdeployer.com/docs/account/dashboard.md

The **Dashboard** is your home screen. It shows what your wallets hold, how your trading is going and which tokens you launched.

![The dashboard: the top row, Performance, Your tokens and Top mooners](https://vortexdeployer.com/docs/account/dashboard.png)

## Open the dashboard

1. Click **Dashboard** in the top bar.
2. Pick a chain at the right end of the top row: **All chains**, **Solana** or **Robinhood**. Every figure on the page follows this choice.

## The top row

- **Wallet Value** — what all your wallets hold right now. With one chain picked, it shows SOL or ETH. With **All chains**, it shows US dollars. It reads **Estimated Wallet Value** when some tokens have no price yet or the figure is still updating.
- The small green or red figure beside it is the change over the last 24 hours. Deposits and withdrawals count too, so this change is not profit.
- **Total P&L** — your all-time [P&L](https://vortexdeployer.com/docs/other/glossary#pnl) from trading. Under it, **Cash flow** is what your sells brought in minus what your buys cost. **Holdings** is what the tokens you still hold would bring if you sold them now. It reads **Estimated P&L** when part of it is an estimate.
- **Tokens Launched** — real tokens you launched. Drafts, simulated launches and projects you imported or took over with CTO do not count.
- **Tokens Migrated** — launches that filled their [bonding curve](https://vortexdeployer.com/docs/other/glossary#bonding-curve) and moved to a full trading pool. This move is called a [migration](https://vortexdeployer.com/docs/other/glossary#migration). The line under it shows how many launches could migrate and how many are still on the curve.

Two small buttons sit next to the wallet label:

- **Hide balances** (the eye) — swaps every amount for dots. Click **Show balances** to bring them back. This helps when you share your screen.
- **Scan portfolio** — opens a read-only summary for each chain. It shows the coin in your wallets, the value of the tokens you hold, and lists of wallets and open positions. **Full portfolio** opens the [Portfolio](https://vortexdeployer.com/docs/account/portfolio) page. **Fund / recover** opens **Wallets**.

## Performance

This panel shows your results over time. Pick a view at the top:

- **Calendar** (the default) — one box per day. Each box shows sells minus buys for that day, in UTC time. Click a day to see its figure. Otherwise the panel shows the **Month total**.
- **P&L** — a line of your running trade cash. Pick **Last 7 days**, **Last 30 days** (the default) or **Last 90 days**.
- **Balance** — your wallet balance over time.

![Switching Performance between Calendar, P&L and Balance](https://vortexdeployer.com/docs/account/dashboard.mp4)

:::info Tokens you still hold are not counted here
**Calendar** and **P&L** only count cash from buys and sells that went through. Tokens you still hold get no value here. That is why these views can differ from **Total P&L**, which adds **Holdings**.
:::

A note such as "2 days pending" means some trade amounts are still being settled. The line updates by itself.

### Share a P&L card

1. Click **Share** in the **Performance** panel.
2. Pick a **Card period**: **1D**, **7D** (the default) or **30D**.
3. Under **Card background**, keep **Default** or pick **Custom image** to upload your own picture.
4. Tick **Show @username** to print your username on the card. It is greyed out if you have no username.
5. Click **Copy** or **Download PNG**.

![The P&L card window](https://vortexdeployer.com/docs/account/dashboard-share.png)

**Share** is greyed out while balances are hidden, and before you have any trades.

## Your tokens

This list shows the tokens from your projects.

- Filter with **All**, **Live** or **Drafts**. Sort by **Newest** or **P&L**.
- Click a live token to open it in the trading terminal. Click a draft to finish it.
- The list shows up to 50 tokens. Click **View all N tokens** or **Open projects** to see every project.

If you have no projects yet, a **Get started** checklist takes this spot. Pick a goal (**Launch**, **Trade** or **Wallets**) and follow the steps: create a wallet, fund it, then launch, trade or organize.

## Top mooners

This list shows other people's tokens from the last 24 hours that rose to at least 8 times their starting price. Each did so within 10 minutes of launch. Each one also has at least $500 of [liquidity](https://vortexdeployer.com/docs/other/glossary#liquidity).

- Sort by **Newest** or **Highest peak**.
- Click a name to open the token in the terminal. The arrow button opens it on a block [explorer](https://vortexdeployer.com/docs/other/glossary#explorer).
- Your own tokens never appear here.

:::warning A past jump is not a promise
These tokens already moved a lot. Buying one spends real SOL or ETH, and its price can fall fast.
:::

## Troubleshooting

**"Some dashboard data could not be refreshed"** — Click **Retry now** on the notice. Until then, the page shows the last figures that loaded.

**A day in the calendar is empty** — No trades went through that day, or they are still settling.

## See also

- [Portfolio](https://vortexdeployer.com/docs/account/portfolio)
- [P&L share cards](https://vortexdeployer.com/docs/terminal/pnl-cards)
- [Find your way around](https://vortexdeployer.com/docs/overview/workspace)

---

# Portfolio

> See what your trading made or lost, what your tokens are worth now, and export the numbers.

Source: https://vortexdeployer.com/docs/account/portfolio · Markdown: https://vortexdeployer.com/docs/account/portfolio.md

**Portfolio** shows your trading results on one chain. It shows what you spent, what you got back, and what the tokens you still hold are worth.

![The Portfolio page](https://vortexdeployer.com/docs/account/portfolio.png)

## Open Portfolio

1. Click your name at the top right to open the user menu.
2. Click **Portfolio**.
3. Pick **Solana** or **Robinhood** at the top right. Portfolio shows one chain at a time. On Robinhood, every SOL label reads ETH.

You can also click **Full portfolio** in the **Scan portfolio** window on the [Dashboard](https://vortexdeployer.com/docs/account/dashboard).

## What P&L means

[P&L](https://vortexdeployer.com/docs/other/glossary#pnl) means profit and loss. Green means you are ahead. Red means you are behind. Portfolio splits it into two parts:

- **Realized** — everything your sells brought in, minus everything your buys cost. This part only changes when you trade.
- **Bag value** — what the tokens you still hold would bring if you sold all of them now. This is your [bag](https://vortexdeployer.com/docs/other/glossary#bag). It moves with the price, so it changes all the time. Some apps call this part "unrealized".

**Total position P&L** adds the two together.

> Example: you buy a token for 1 SOL. Later you sell half of it for 0.8 SOL. Realized is 0.8 − 1 = −0.2 SOL. The half you kept would sell for 0.7 SOL now, so bag value is 0.7 SOL. Total position P&L is −0.2 + 0.7 = +0.5 SOL.

Realized can be negative while you are still ahead. It only turns into profit once you sell the rest.

## The figures at the top

- **Total SOL held** — the SOL in all your wallets on this chain.
- **Realized SOL P&L** — sells minus buys, as above. The line under it shows the fees already inside this figure. Click the figure to see how it adds up.
- **Bag value (SOL)** — your remaining tokens, priced as one full sale right now. The price includes the [price impact](https://vortexdeployer.com/docs/other/glossary#price-impact) of that sale and the [platform fee](https://vortexdeployer.com/docs/other/glossary#platform-fee). The line under it reads **Full-bag sell quote**, or **Saved valuation** when it shows the last saved figure.
- **Total position P&L** — realized plus bag value.
- **Trades landed** — how many buys and sells went through, and when the last one was.
- **Active wallets** — how many wallets traded, across how many tokens.

## The panels

- **Position P&L by token** — one row per token, with **Buys · Sells**, **Realized**, **Bag (live)** and **Total**. **Trade** opens the token in the terminal.
- **Open token holdings** — tokens you hold now, how many, their value and which wallets hold them. **Sell** opens the trade panel with those wallets already picked.
- **SOL by wallet** — the SOL balance of each wallet.

A wallet needs a little SOL or ETH to pay the network fee for a sell. This is called [gas](https://vortexdeployer.com/docs/other/glossary#gas). Under 0.005 SOL (0.0005 ETH on Robinhood), a holding shows "N need gas". **Fund** sends gas to those wallets. **Fund N for gas** at the top of the panel does it for every holding at once.

:::warning Funding spends real coin
**Fund** and **Fund N for gas** open the fund window. Sending gas moves real SOL or ETH from your wallet to those wallets.
:::

## Explain and export your P&L

1. Click **Explain & export** at the top right.
2. The **Explain portfolio P&L** window lists **Spent on buys**, **Received from sells**, **Trade cash: received minus spent**, **Remaining holdings: estimated exit value**, **Total position P&L** and **Fees already included**.
3. Click **Export this summary** to save these figures as a CSV file.
4. Under **Recorded trade receipts**, check each trade. Click **Load older receipts** to see more.
5. Click **Export loaded receipts (N)** to save the trades you loaded as a CSV file.

![The Explain window with its figures and receipts](https://vortexdeployer.com/docs/account/portfolio-explain.png)

:::info Two things P&L leaves out on purpose
Deposits and withdrawals are not trading profit, so they never count. Fees are already inside the figures. Do not subtract them again.
:::

## Why two screens can show different numbers

You can see a token's P&L in two places: the **PnL** figure in the trading terminal, and Portfolio or the Dashboard.

- The terminal counts your trade as soon as it shows up on the chain. Portfolio counts it once it is saved to your trade history. Right after a trade, the two can differ for a short time.
- Bag value follows the price, so it changes from minute to minute.
- On the Dashboard, **Calendar** and **P&L** count only cash from buys and sells. **Total P&L** also adds the tokens you hold.

If the terminal and Portfolio still differ after a few minutes, a trade may not have been saved correctly. Open a [support ticket](https://vortexdeployer.com/docs/account/support) and include the token address.

## Troubleshooting

**"Some wallet balances are still updating. Totals are incomplete."** — Wait a moment. The figures fill in by themselves.

**"Total P&L unavailable: some holdings are unvalued."** — Click **Refresh holdings**.

**A token shows a dash under Bag (live)** — No pool trades that token for SOL, so it cannot be valued. Its realized part still counts.

## See also

- [Dashboard](https://vortexdeployer.com/docs/account/dashboard)
- [The terminal](https://vortexdeployer.com/docs/terminal/overview)
- [Sell all](https://vortexdeployer.com/docs/terminal/sell-all)
- [Fund wallets](https://vortexdeployer.com/docs/wallets/fund)

---

# Operation progress

> Follow a token conversion or a project closeout, and stop or continue the rest of it.

Source: https://vortexdeployer.com/docs/account/operations · Markdown: https://vortexdeployer.com/docs/account/operations.md

Some jobs work through many wallets one by one. A token conversion (**Convert**) and a project closeout (**Close out**) are two of them. The **Operation details** window shows how far such a job got, and what happened to each wallet.

## Open the window

- When you start a real conversion in **Convert**, the window opens by itself, over the page you are on.
- When an operation finishes, stops or needs you, the bell in the bottom bar gets a [notification](https://vortexdeployer.com/docs/account/notifications). Click it to open the window.
- The window lives in the page address. Reload the page and it opens again.

A closeout also shows its progress inside its own **Close out projects** window. See [Close out](https://vortexdeployer.com/docs/launch/close-out).

:::info It keeps going without you
The job runs on our servers. Closing the window or the browser tab does not stop it.
:::

## Read the window

![An operation window](https://vortexdeployer.com/docs/account/operations.png)

The left side shows the job as a whole:

- The title: **Token conversion** or **Project closeout**. **· Simulation** after it means a [dry run](https://vortexdeployer.com/docs/other/glossary#dry-run) that sent nothing. The app no longer starts these. They come from older runs or from the API.
- "N of M processed" and a progress bar.
- How many items are **Queued** and how many **Needs attention**.
- **Operation reference** — a code for this job. Give it to support if you need help.

Each item has one of these statuses:

| Status | What it means |
|---|---|
| **Queued** | Waiting for its turn |
| **In progress** | Being worked on now |
| **Awaiting confirmation** | Sent; the result is still being checked |
| **Completed** | Done |
| **Needs attention** | Something went wrong; read the detail |
| **Stopped** | Stopped before it started |

Under an item you may see:

- **Open wallet** — opens that wallet.
- **Per-wallet results (N)** — the result for each wallet in the item.
- **Follow sweep task #N** — a closeout started a [task](https://vortexdeployer.com/docs/other/glossary#task) to collect funds. This opens it.
- A transaction link — opens the [transaction](https://vortexdeployer.com/docs/other/glossary#transaction) on a block [explorer](https://vortexdeployer.com/docs/other/glossary#explorer).

## Stop or continue

- **Check status** — loads the latest saved state.
- **Stop remaining items** — queued items will not start. Items already sent may still finish.
- **Continue remaining items** — shows when some items need attention and others still wait. It skips the items that need attention and starts only the queued ones.

:::warning Check before you retry
An item that needs attention may still have gone through on the chain. Open its transaction link first. Starting the same job again spends real SOL or ETH a second time. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
:::

## Keep a window running in the background

Windows that move money for many wallets have a **Minimize** button (the dash at the top right). This includes **Fund wallets**, **Collect funds**, **Warm up wallets**, **Dev warmup**, **Claim cashback**, **Convert** and **Closeout**.

1. Click **Minimize**. The window hides, and a chip with its name appears in the bottom bar.
2. Keep working. A thin bar on the chip shows progress when there is one.
3. Click the chip to bring the window back.

**Convert** and **Closeout** stay open while you move between pages. Keep the browser tab open while **Convert** is still checking wallets. The other windows belong to the page that opened them. If you leave that page, the chip goes away, but the job it started keeps running.

## Troubleshooting

**"Updates interrupted. Showing the last saved state."** — Your connection dropped. Click **Check status**. A lost connection does not mean the job failed.

**An item says Needs attention** — Read its detail and open its transaction link before you do anything else.

## See also

- [Notifications](https://vortexdeployer.com/docs/account/notifications)
- [Close out](https://vortexdeployer.com/docs/launch/close-out)
- [Wallets overview](https://vortexdeployer.com/docs/wallets/overview)
- [Support](https://vortexdeployer.com/docs/account/support)

---

# Notifications

> Read updates about your tasks, conversions and orders, and get them in your browser or on Telegram.

Source: https://vortexdeployer.com/docs/account/notifications · Markdown: https://vortexdeployer.com/docs/account/notifications.md

The bell in the bottom bar collects updates about your [tasks](https://vortexdeployer.com/docs/other/glossary#task), your conversions and closeouts, and your marketplace orders. A number on the bell shows how many you have not read yet.

## Read your updates

1. Click the bell at the bottom right of the screen. The **Notifications** panel opens above it.
2. Click an update to open it. A task or an operation opens in a window over the page you are on. A marketplace order opens on **Marketplace**.
3. The update is now marked as read, and the panel closes.

![The Notifications panel above the bell](https://vortexdeployer.com/docs/account/notifications.png)

More controls in the panel:

- **Unread** — shows only updates you have not read. Click it again to see all of them.
- **Mark all read** — marks every update as read.
- **Older** — shows earlier updates. **Newest** takes you back to the latest ones.
- Press **Escape** or click outside the panel to close it.

A dot marks an update you have not read. An amber dot means the update needs your attention. Hover over an update to see its full text and exact time.

## What sends an update

| Update | When you get it |
|---|---|
| **Task completed** | A task finished |
| **Task needs attention** | A task failed |
| **Operation complete** | A conversion or closeout finished |
| **Confirmation pending** | A conversion or closeout is waiting for the chain to confirm |
| **Queue stopped** | A conversion or closeout was stopped |
| **Operation needs attention** | Part of a conversion or closeout went wrong |
| **Your wallets are ready** | A wallet order from **Marketplace** is done |
| **Wallet reservation expired** | A wallet order ran out of time |
| **Marketplace payment needs review** | The payment for a wallet order needs a review |

Replies to your support tickets do not show up here. They show as **New reply** on the [Support](https://vortexdeployer.com/docs/account/support) page.

## Get updates outside the app

Updates always stay in the bell. You can also have them sent to your browser or to Telegram.

1. Click **Delivery settings** at the bottom of the panel. You can also open **Account settings** from the user menu and pick **Notifications**.
2. Under **Delivery**, switch on the channels you want. Changes save by themselves.

- **Browser notifications** — pop-ups from your browser. Your browser asks for permission the first time. They only arrive while the app is open in a tab.
- **Telegram notifications** — messages from our bot, even when the app is closed. Each message has the title, the details and a link. This needs an account that signs in with Telegram. If the switch is greyed out, the line beside it says why.

:::info Delivery is not the result
"Telegram delivery failed" or "Telegram delivery not confirmed yet" only tells you about the message. It says nothing about the task or operation itself. Open the update to see what really happened.
:::

## Troubleshooting

**Browser pop-ups never appear** — Check that your browser allows notifications for this site. Keep the app open in a tab.

**"Needs a Telegram-linked account."** — Telegram delivery only works for accounts that sign in with Telegram. Use browser notifications instead.

**"Not configured on this server."** — Telegram delivery is not set up right now. Updates still reach the bell.

## See also

- [Operation progress](https://vortexdeployer.com/docs/account/operations)
- [Settings](https://vortexdeployer.com/docs/account/settings)
- [How tasks run](https://vortexdeployer.com/docs/tasks/overview)

---

# Settings

> Set your quick-trade amounts, confirmations, launch defaults and how the app looks.

Source: https://vortexdeployer.com/docs/account/settings · Markdown: https://vortexdeployer.com/docs/account/settings.md

**Settings** holds your defaults: the amounts on your trade buttons, the values Quick deploy starts with, your supply plans and a few display choices. Your settings are saved to your account, so they follow you to every browser you sign in on.

## Open Settings

1. Click your name at the top right.
2. Click **Account settings**.
3. Pick a section on the left. On a phone, the sections are a row of tabs at the top.

![Account settings on Trading](https://vortexdeployer.com/docs/account/settings.png)

![Account settings on a phone, with the sections as a row of tabs](https://vortexdeployer.com/docs/account/settings-phone.png)

| Section | What it holds |
|---|---|
| **Profile** | Your name and how you sign in |
| **Notifications** | Browser and Telegram delivery |
| **Trading** | Quick-trade amounts, confirmations, sell route |
| **Quick deploy** | One-click launch defaults |
| **Supply plans** | % of supply per wallet |
| **Workspace** | Display, tasks, saved setups |

**Notifications** and **Workspace** save by themselves. The other sections have a save button at the bottom. You can switch sections without losing unsaved edits.

**Profile** is explained on [My profile](https://vortexdeployer.com/docs/account/profile), and **Notifications** on [Notifications](https://vortexdeployer.com/docs/account/notifications).

## Trading

### Quick-trade presets

These are the amounts on the one-click buy and sell buttons in the trading terminal. You can keep three sets: **PRESET 1**, **PRESET 2** and **PRESET 3**.

1. Pick a preset at the top.
2. Edit the lists. Click **Add** to add an amount, or the small x to remove one. Each list holds up to 6 amounts.
3. Click **Save trading settings**. The preset you are looking at becomes the active one.

- **Buy amounts · Solana** — in SOL. Default 0.01, 0.05, 0.1, 0.5 and 1.
- **Buy amounts · Robinhood** — in ETH. Default 0.001, 0.005, 0.01, 0.05 and 0.1.
- **Sell sizes** — in % of what a wallet holds. Default 25, 50, 75 and 100.
- **Randomize** — off by default. When on, each quick trade changes the amount a little, within the band you set (0 to 90 % each way). On a wallet row, **MAX** and 100 % sells stay exact. A **MAX** buy in the **Trade panel** can change too.
- **Advanced settings** → **Default slippage (bps)** — how far the price may move before a trade is refused. Default 300 [bps](https://vortexdeployer.com/docs/other/glossary#bps), which is 3 %. Allowed: 1 to 10000. The app warns you above 1000. See [slippage](https://vortexdeployer.com/docs/other/glossary#slippage).
- **Reset slot** — puts this preset back to the defaults.

:::warning Some buttons trade on the first click
Saving presets moves no money. But on a wallet row and in the **Trade panel**, clicking an amount sends a real trade at once. In the order ticket, clicking an amount only fills it in.
:::

### Confirmations

Both are off by default. Click **Save trading settings** after you change them.

- **Confirm dev trades** — asks you first before a quick trade that includes a wallet with the dev role. See [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet).
- **Confirm Sell all** — asks you first before **Sell all**, **Sell all (excl dev)** or **Sell dev** sells 100 % from your wallets.

### Sell through another wallet

With this on, a sale goes through a fresh, temporary wallet. Your tokens move there, that wallet sells, and the money comes back to you. Click **Save sell setting** after you change it.

- **Off** — sell from your own wallets (the default).
- **All sells** — use a temporary wallet for every sale.
- **Custom** — pick which **Manual sells** and which **Task types** use one.

:::warning It costs more per sale
On Solana, each sale takes two transactions. One sends 0.01 SOL and your tokens to the temporary wallet. The other sells and sends all the SOL back. You pay network fees on both. On Robinhood, a sale may also need a [token approval](https://vortexdeployer.com/docs/other/glossary#token-approval).
:::

## Quick deploy

These are the values [Quick deploy](https://vortexdeployer.com/docs/other/glossary#quick-deploy) starts with: the launchpad, symbol, image, dev wallet, dev buy and launch tasks. You can keep three sets, **PRESET 1** to **PRESET 3**. Click **Save PRESET N** to save one. That preset becomes the one Quick deploy uses, marked with a dot. Saving launches nothing.

How to fill in each field is on [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy). If a saved wallet was deleted, it is removed from the preset and a warning asks you to save again.

## Supply plans

A [supply plan](https://vortexdeployer.com/docs/other/glossary#supply-plan) saves how much of a token's supply each wallet buys, in %. How to make and use one is on [Supply plans](https://vortexdeployer.com/docs/account/supply-plans).

## Workspace

- **Display density** — **Compact** (the default) or **Comfortable**. Sets the space between controls.
- **One task per wallet** — off by default. When on, a wallet in a running or paused task cannot be picked for another task.
- **Saved setups** — saves your trading and launch defaults under one name, up to 20 setups. Type a name and click **Save setup**. **Load** puts a setup back into the forms. Loading never trades or launches.
- **Account sync** — shows whether your settings reached your account. **Sync now** checks again. If this browser and your account differ, pick **Use account version** or **Keep this version**.
- **More options** → **Reload forms from saved settings** — throws away unsaved edits and loads your saved defaults.

## Troubleshooting

**"Review account sync" shows at the top** — Open **Workspace** and pick which version of each setting to keep.

**"Add at least one amount to save this preset."** — Every list needs at least one amount. Zero and repeated amounts are not allowed.

## See also

- [Quick deploy](https://vortexdeployer.com/docs/launch/quick-deploy)
- [Trade panel](https://vortexdeployer.com/docs/terminal/trade-panel)
- [Supply plans](https://vortexdeployer.com/docs/account/supply-plans)
- [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run)

---

# Supply plans

> Save how much of a token's supply each wallet should buy, then use that plan in buy forms.

Source: https://vortexdeployer.com/docs/account/supply-plans · Markdown: https://vortexdeployer.com/docs/account/supply-plans.md

A [supply plan](https://vortexdeployer.com/docs/other/glossary#supply-plan) says how much of a token's supply each wallet buys, in %. You make it once. Then any form with a **Supply plan** picker can turn it into amounts for that token.

## Open Supply plans

1. Click your name at the top right.
2. Click **Account settings**.
3. Pick **Supply plans** on the left.

![Supply plans in Account settings](https://vortexdeployer.com/docs/account/supply-plans.png)

You can also click **Manage plans** next to any **Supply plan** picker.

## Make a plan

1. Under **New plan**, type a **Plan name**, up to 60 characters.
2. Add the slots. Each slot is one wallet's share of the supply, in %. Slot 1 buys first, then slot 2, and so on.
   - To fill many slots at once, set the number of slots and the % for each, then click **Even split**. This replaces the slots you had.
   - Click **Add slot** to add one more. Click the small x on a row to remove it.
3. Optional: pick a [wallet role](https://vortexdeployer.com/docs/other/glossary#wallet-role) for a slot. Only a wallet with that role can fill it. **Any role** lets any wallet fill it.
4. Optional: pick a wallet for a slot. That wallet always fills it, whatever its role. **Any selected wallet** leaves the slot to the wallets you pick in the form.
5. Optional: set the limits below.
6. Click **Create plan**. Or click **Save & preview in SOL and ETH** to save it and see the amounts.

The total of all slots shows above the list. It can be at most 100 %.

:::tip Keep the dev wallet out of a Snipe
Give slot 1 the role **Dev** and the other slots **Trading (no role)**. Then a Snipe never picks your [dev wallet](https://vortexdeployer.com/docs/other/glossary#dev-wallet) for the other slots.
:::

## Limits

- **Plan cap** — the most the whole plan may buy, in % of supply. Empty means off. The slots together cannot be more than the cap.
- **Per-wallet ceiling** — the most one wallet may hold, in % of supply. Empty means the size of your largest slot. No slot can be bigger than it. A task that uses the plan skips a buy from a wallet that already holds this much.

## Preview the amounts

**Save & preview in SOL and ETH** shows two tables: Solana in SOL and Robinhood in ETH. Each prices the plan on a brand-new [bonding curve](https://vortexdeployer.com/docs/other/glossary#bonding-curve), where nobody has bought yet. The amounts assume nobody else buys in between, so they are a best case.

## Use a plan in a form

The **Supply plan** picker shows in new and edited buy [tasks](https://vortexdeployer.com/docs/other/glossary#task), on buy cards in the launch wizard, and in **Fund wallets**.

1. Select the wallets in the form first. The plan fills its slots with them, in order. If you select none, it uses all the wallets the form offers.
2. Pick a plan in **Supply plan**. Each entry shows its name, its number of slots and its total %.
3. Click **Mount**. The app prices each slot for this token and fills the form.
4. Check the table under the picker. Then save or start the form as usual.

The table shows each slot's **Wallet**, **Target**, what it **Lands** and its cost. It can also show the **Balance**, what is **Short** and what each wallet **Holds** now. If you change the wallets, click **Re-mount**.

What the form takes from the plan:

- **Buy tasks and launch buy cards** — the amount for each wallet and the per-wallet ceiling.
- **Some other tasks** — the wallets and the per-wallet ceiling.
- **Fund wallets** — each wallet that is short of its planned buy gets exactly what it lacks.

:::info Mounting moves no money
**Mount** only fills in the form. Nothing buys or sends until you start the task, launch, or send the funds.
:::

## Edit or delete a plan

Your saved plans show under **Your plans**, with their total %.

- **Edit** — click a plan. The form above changes to **Edit plan**. Make your changes and click **Save plan**.
- **Delete** — click the bin next to a plan. It is deleted at once, with no question first.

:::warning The name is what saves a plan
Saving under a new name makes a new plan, and the old one stays. Saving a new plan with the name of one you have replaces that plan.
:::

## Troubleshooting

**"Slots add up to … — more than the whole supply"** — Lower some slots so the total is 100 % or less.

**"A slot targets more than the per-wallet ceiling"** — Raise the **Per-wallet ceiling**, or lower that slot.

**"… slots without a wallet — select more wallets to fill the plan"** — The form has fewer wallets than the plan has slots. Select more wallets, then click **Re-mount**.

**An error that starts with "supply plan:" when you click Mount** — The plan cannot be priced for this token. For example, StonkFun curves are not priced yet. Enter the amounts by hand.

## See also

- [Buy](https://vortexdeployer.com/docs/tasks/buy)
- [Snipe](https://vortexdeployer.com/docs/tasks/snipe)
- [Fund wallets](https://vortexdeployer.com/docs/wallets/fund)
- [Settings](https://vortexdeployer.com/docs/account/settings)

---

# My profile

> See your account at a glance and set up a username and password for browser sign-in.

Source: https://vortexdeployer.com/docs/account/profile · Markdown: https://vortexdeployer.com/docs/account/profile.md

Your profile shows who you are signed in as, a few totals, and how you sign in. You can also add a username and password, so you can sign in from any browser, not only through Telegram.

## See your profile

Your account details are in two places:

- **Account settings** → **Profile**. Click your name at the top right, then **Account settings**. The first section shows **Display name**, **Username** (or "Not set"), **Sign-in method** and **Account ID**. This is also where you change your sign-in details.
- The **My profile** page, at the address `/myprofile`. It has no menu link, so type the address after the site name.

![My profile. The user ID is blurred here.](https://vortexdeployer.com/docs/account/profile.png)

The **My profile** page shows:

- Your name, and "Signs in with Telegram" or "Signs in with Password".
- Your user ID. Click it to copy it. Support may ask you for it.
- **Net P&L** — your trading result on the chain you last picked on [Portfolio](https://vortexdeployer.com/docs/account/portfolio). [P&L](https://vortexdeployer.com/docs/other/glossary#pnl) means profit and loss. Click it to open Portfolio.
- **Launches** — how many of your projects have a launched token. Click it to open **Projects**.
- **Wallets** — how many wallets you have. Click it to open **Wallets**.
- **Browser sign-in** — whether you can sign in with a username and password. **Set up sign-in** or **Open settings** takes you to the form.

## Sign-in details

**Account settings** → **Profile** is also where you add a username and password, or change them. Browser sign-in unlocks at the Silver [fee tier](https://vortexdeployer.com/docs/other/glossary#fee-tier). Until then, the form says "Password sign-in is off for this account; the operator enables it." The steps are on [Sign in & accounts](https://vortexdeployer.com/docs/overview/sign-in#add-a-username-and-password).

:::warning Saving signs you out elsewhere and stops your API keys
New sign-in details sign out every other browser and stop all your [API keys](https://vortexdeployer.com/docs/other/glossary#api-key). Make new keys afterwards if you use them.
:::

## Troubleshooting

**You cannot find My profile in the menu** — It has no menu link. Type `/myprofile` after the site name.

**"Password sign-in is off for this account; the operator enables it."** — You have not reached the Silver tier yet. Keep signing in through Telegram, or ask [Support](https://vortexdeployer.com/docs/account/support).

## See also

- [Sign in & accounts](https://vortexdeployer.com/docs/overview/sign-in)
- [Settings](https://vortexdeployer.com/docs/account/settings)
- [Account settings & KOLs](https://vortexdeployer.com/docs/api/account)
- [Support](https://vortexdeployer.com/docs/account/support)

---

# Referrals

> Invite people with your link, see what you earn from their fees, and claim your earnings.

Source: https://vortexdeployer.com/docs/account/referrals · Markdown: https://vortexdeployer.com/docs/account/referrals.md

Invite people with your own link. When they pay [platform fees](https://vortexdeployer.com/docs/other/glossary#platform-fee), you get a share, and you can claim it to your wallet.

## Open Referrals

1. Click your name at the top right. On a phone, open the menu.
2. Click **Referrals**.

![Referrals: the invite link, the levels and the claim form. The link and code are blurred here.](https://vortexdeployer.com/docs/account/referrals.png)

Three figures show at the top. Click **Refresh** to load the latest.

- **People you referred** — everyone in your network, across levels 1, 2 and 3.
- **Paid out** — what has been paid to you so far.
- **Your rates** — your share of the platform fees at level 1, level 2 and level 3.

## How the levels work

- **Level 1** — people who joined with your link or your code.
- **Level 2** — people your level 1 invited.
- **Level 3** — people your level 2 invited.

When someone in your network pays a platform fee, your rate for their level is added to your balance. It is added in the coin the fee was paid in, SOL or ETH. The table under **Your invite link** shows the **People**, **Rate** and **Earned** for each level. **Earned** is shown in SOL.

## Invite someone

1. Under **Your invite link**, click **Copy link**. It changes to **Copied**.
2. Send the link to the person you want to invite.
3. They open the link, then sign up or sign in in that same browser tab.
4. They become your level 1, if nobody invited them before.

If the link did not work for them, they can type your [referral code](https://vortexdeployer.com/docs/other/glossary#referral-code) by hand. See "Were you invited?" below.

## Change your referral code

Your code is the last part of your invite link.

1. Type a new code in **Referral code**. Use 3 to 50 letters, numbers, `-` or `_`.
2. Click **Save code**. You see "Referral code saved".

People you already invited stay in your network. But old links with your old code stop working, so share your new link.

## Were you invited?

This box shows only if nobody invited you yet.

1. Type the code of the person who invited you.
2. Click **Apply**. You see "Invitation attached".

:::info You can only do this once
An invitation cannot be changed or removed later. And once you have invited people yourself, you can no longer add an inviter.
:::

## Claim your earnings

1. Under **Claim your earnings**, pick the chain. **Solana · SOL** is always there. Other chains show once you earn on them.
2. Check **Available now**. This is what you can claim on that chain.
3. Type the amount, and the **Payout wallet address** on that same chain.
4. Click **Request payment**. You see "Payment request submitted".

Your request is checked by the team before it is paid. You can have one open request per chain at a time.

:::warning Check the payout address
The payment goes to the address you type. Check it twice before you click **Request payment**. A payment that went to a wrong address cannot be undone.
:::

## Follow your payment requests

**Your payment requests** lists each request with its number, its amount and its status:

- **pending** — waiting for review. Click **Cancel claim** to cancel it.
- **approved** — accepted and waiting to be paid. It can no longer be cancelled.
- **paid** — sent to your wallet. A link to the [transaction](https://vortexdeployer.com/docs/other/glossary#transaction) shows under it.
- **rejected** — not paid. The amount goes back to **Available now**.
- **cancelled** — you cancelled it. The amount goes back to **Available now**.

## Troubleshooting

**"referral code not found"** — The code is wrong, or its owner changed it. Ask them for their current link.

**"a referral is already attached to this account"** — You already have an inviter. It cannot be changed.

**"a claim is already pending or approved on this chain"** — Wait until your open request is paid. If it is still **pending**, you can cancel it and ask again.

**"invalid payout wallet address"** — The address is not a valid address on the chain you picked.

## See also

- [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees)
- [My profile](https://vortexdeployer.com/docs/account/profile)
- [Support](https://vortexdeployer.com/docs/account/support)

---

# Support

> Ask for help, report a bug or suggest a feature, and follow the replies.

Source: https://vortexdeployer.com/docs/account/support · Markdown: https://vortexdeployer.com/docs/account/support.md

You talk to support through tickets. A ticket is a short written conversation with our team. You can ask a question, report a bug or suggest a new feature.

## Open a ticket

![The top of Support tickets: Contact support, Request a feature, Report a bug and the filters](https://vortexdeployer.com/docs/account/support.png)

1. Open the window you need:
   - Click your name at the top right, then **Support**. On the **Support tickets** page, click **Contact support**, **Request a feature** or **Report a bug**.
   - Or use the buttons in the bottom bar of any page: **Bug** (the bug icon) or **Suggest** (the light bulb). **Help** there opens the **Support tickets** page. On narrow screens only the icons show. On a phone, open the menu (the three lines at the top) and pick **Report a bug** or **Suggest a feature**.
2. Check the **Kind** at the top: **Support**, **Feature request** or **Report a bug**. You can switch it here.
3. Type a short **Subject**: at least 3 characters, at most 160.
4. Fill in **Details**: at least 5 characters. Add the token address, wallet or task number if it matters.
5. Click **Submit**.

You see "Thanks — your … was submitted." and your ticket number, such as **Ticket #123**. Click **Done** to close the window.

:::warning Never send your private keys
Do not paste a wallet's private key or your password into a ticket. Anyone who has a private key can take that wallet's funds.
:::

## Report a bug well

A bug report starts with three headings already filled in: **What I did**, **What I expected** and **What happened**.

![The Report a bug window. Details already holds the What I did, What I expected and What happened headings.](https://vortexdeployer.com/docs/account/support-report-bug.png)

1. Under **What I did**, list your steps, one per line.
2. Under **What I expected**, say what should have happened.
3. Under **What happened**, say what really happened. Paste any error text you saw.

The report is refused if you leave the headings empty. Open the report from the page where the problem happened. The app then adds some details for you:

- the page and its address
- your screen size, browser, language and time zone
- the chain you picked
- recent errors from the page

Other kinds of tickets only add the page and your browser.

## Suggest a feature

Click **Request a feature** or **Suggest**. Put the idea in one line in **Subject**. In **Details**, say what you want to do, why, and how it could work.

## Follow your tickets

The **Support tickets** page lists your tickets, the most recently active first, up to 100.

- Filter by kind with **All**, **Support**, **Feature requests** or **Bugs**.
- Filter by **Status**: **Open**, **In progress**, **Resolved** or **Closed**. Only support changes the status.
- A **New reply** label means support wrote back and you have not read it yet.

To reply:

1. Click a ticket to open its conversation.
2. Type in **Add a reply…**.
3. Click **Send**, or press Ctrl+Enter (Cmd+Enter on a Mac).

:::info Check this page for replies
Support replies do not show up in the bell. Come back to **Support tickets** and look for **New reply**.
:::

## Troubleshooting

**"Add a short subject (3+ chars)"** — Type a longer **Subject**.

**"Fill in what you did and what happened"** — Write under the bug report headings before you submit.

**The ticket does not submit** — Your text stays in the window. Read the red message, then click **Submit** again.

## See also

- [Troubleshooting](https://vortexdeployer.com/docs/other/troubleshooting)
- [Notifications](https://vortexdeployer.com/docs/account/notifications)
- [Operation progress](https://vortexdeployer.com/docs/account/operations)

---

# Terminology

> Every word the app and these docs use, explained in plain language.

Source: https://vortexdeployer.com/docs/other/glossary · Markdown: https://vortexdeployer.com/docs/other/glossary.md

New to launching or trading tokens? This page explains the words you will meet in the app and in these docs. Pages link here the first time they use a word, so you can jump in and back.

## Basics

#### Burn

To destroy tokens for good. Burned tokens leave the supply and never come back.

#### Chain

The blockchain a wallet or token lives on. VortexDeployer works on Solana and Robinhood Chain.

#### Contract address

The address that names one token on the chain. Also called the CA or mint.

#### Dead address

An address on Robinhood Chain that no one controls. It ends in dEaD. Tokens sent there can never move again.

#### Dry run

A test run that shows what would happen without sending anything. It spends no money. The app's screens no longer offer one, but the API still does, and old test runs still show as **Simulated**.

#### Explorer

A public website that shows every transaction and wallet on a chain, such as Solscan for Solana.

#### Holder

A wallet that holds some of a token. Explorers count holders to show how widely a token is spread.

#### Lock

To put tokens where nobody can move or sell them until a date you set. A hard lock cannot be opened early, not even by its owner.

#### Mint address

The address that names one token on Solana. Paste it to pick that token.

#### Preset

A saved setup you can reuse with one click. Quick deploy keeps three launch presets (PRESET 1, 2 and 3). The terminal keeps three sets of buy amounts and sell sizes for its quick-trade buttons.

#### Robinhood Chain

A separate blockchain that uses ETH for fees. The app launches tokens there on pons.

#### Streamflow

An outside Solana app that holds locked tokens until their unlock date. The app's Lock button uses it.

#### Supply

The total number of a token's coins. "% of supply" means that share of all the coins.

#### Telegram bot

The VortexDeployer bot on Telegram, @DeployOnVortexBot. It gives you the button you use to sign in.

#### Terminal

The screen where you watch and trade one token.

#### Token

A coin you create or trade, such as a new pump.fun coin.

#### Transaction

One action recorded on the chain, such as a buy, a sell or a transfer. Once it lands, it cannot be undone.

#### Transaction signature

The id of one transaction on the chain. Paste it into a block explorer to see the transaction.

#### XID

The app's live feed of posts and activity from chosen X accounts.

## Wallets & money

#### Aged wallet

A wallet that is weeks or months old and already has real trades. It looks like a normal trader's wallet.

#### Attached wallet

A wallet you added to a token, so it shows in that token's terminal and can trade it.

#### Base58

The way Solana writes keys and addresses: a long string of letters and digits. Phantom shows private keys this way.

#### CEX

A central exchange, like Binance or Coinbase. A company holds the funds for you.

#### Deposit address

An address made for one order. You send money to it, and the service on the other side pays it out.

#### Dev wallet

The wallet that creates your token, also called the creator wallet. It pays for the launch and makes the dev buy. Wallets with the role **Dev** are meant for this job, but the role alone does not make a wallet the dev wallet of a token.

#### ETH

The coin you pay with on Robinhood Chain. Network fees there are paid in ETH.

#### Folder

A named list you sort pool wallets into, on the Wallets page. A wallet is in one folder at most.

#### Funding source

The exchange or wallet that first sent money to a wallet. Wallets with the same funding source can look related.

#### Gas

The small amount of SOL or ETH a wallet needs to pay the network fee for a transaction.

#### Global pool

Another name for your wallet pool: the wallets under **Global wallets** that belong to no single project. Any project can borrow them.

#### Husher

The outside exchange service the Mixer uses. It pays your wallets from the exchange, and takes its own fee.

#### Mixer

A way to fund or collect through an outside exchange, so your wallets are not linked by direct transfers.

#### Payment address

The address made for one Wallet Marketplace order. You send the order's exact amount to it before the order runs out.

#### Private key

The secret that controls a wallet. Anyone who has it can take everything in the wallet.

#### Project wallet

A wallet that belongs to one project. It shows under that project on the Wallets page.

#### Rent

A small amount of SOL that must stay in a Solana account to keep it open. You get it back when the account is closed.

#### Role

A label on a wallet, such as Dev, Bundle or Trading, that tells tasks which wallets to use.

#### SOL

The coin you pay with on Solana. Network fees on Solana are paid in SOL.

#### Stablecoin

A token meant to stay worth one US dollar, like USDC or USD1.

#### Temporary wallet

A wallet the app makes for one short job and then empties. It is not saved on your Wallets page.

#### Token account

The small account a wallet needs to hold one kind of token. Opening it costs a little rent.

#### Token approval

On Robinhood, a transaction that allows a contract to move your tokens, so it can sell them for you.

#### Vortex Disperse

A way to fund many wallets: your deposit is passed through short-lived in-between wallets, so your wallets are not paid straight from one shared wallet.

#### Wallet

An address on a chain that holds coins and tokens. VortexDeployer creates and runs wallets for you.

#### Wallet Marketplace

The page where you buy ready-made wallets: funded ones, aged ones with trades, and dev wallets. You pay on-chain, and the wallets join your wallet pool.

#### Wallet pool

All the wallets you own in the app, under Global wallets. Projects borrow wallets from it.

#### Wallet role

A short tag that says what a wallet is for, like Dev, Bundle or Sniper.

#### Warm-up

Small real trades that give a new wallet a history, so it does not look brand new.

#### Wrapped SOL

SOL held as a token (wSOL), so it can be traded like other tokens. You can turn it back into plain SOL.

## Launching

#### Bonding curve

The pool a new token trades in right after launch. Its price rises as people buy and falls as they sell.

#### Creator fees

A small share of every trade in your token that the launchpad pays to the creator. Some launchpads let you send it to holders instead.

#### Creator wallet

The wallet that creates your token on the launchpad. It pays the launch costs and makes the dev buy.

#### Dev buy

The first buy of your token, made by the creator wallet in the same moment it creates the token.

#### Draft

A project that is saved but not launched yet. Its token does not exist until it is minted.

#### Graduation

The moment a token's bonding curve fills up. Trading then moves to a normal trading pool.

#### Launch batch

Several launches of the same token setup in a row, from one press of Create. Up to 10.

#### Launch wizard

The step-by-step window where you set up and create a new token.

#### Launchpad

The site and program a token starts on, such as Pump.fun or Bonk.

#### Lookup table

A small list of addresses saved on Solana, so one transaction can fit more buyers. Making one costs rent, which comes back when it is closed.

#### Metadata URI

The web link to a small file with your token's name, symbol, picture and description. Wallets and sites read it to show your token.

#### Migration

The moment a token fills its bonding curve and moves to a full trading pool.

#### Mint

To create a token on the chain. A launch mints the token, then makes the first buys.

#### OTC Desks

A separate site, otcdesks.cash. A Pump.fun token paired with it sends its creator fees there, to pay holders a reward.

#### Pair token

The coin your token is priced in and bought with, such as SOL, USDC or a tokenized stock. It is set at launch.

#### pons

A token launchpad on Robinhood Chain.

#### Project

One token launch in the app, with its own wallets and tasks.

#### Pump coin

Any token that was launched on pump.fun. You can use one as the pair token for a new Pump.fun launch.

#### pump.fun

A Solana launchpad where new tokens start on a bonding curve.

#### Quick deploy

A short form that launches a token in one go, using the defaults you saved in Settings.

#### Quote token

The kind of coin a new token's price is counted in at launch, such as SOL, USDC or a tokenized stock. Some kinds also need the exact coin: the pair token.

#### Scheduled launch

A launch you set to run at a later time. The app sends it for you at that time.

#### Snipe tax

An extra fee pons charges buyers in the first moments after a launch. Snipe wallets on your own pons launch do not pay it.

#### Sniper

Someone who buys a new token in its first seconds, often with a bot, hoping to sell to later buyers.

#### Tokenized stock

A token that follows the price of a real company's stock. Some launchpads let you price a new token in one.

#### Vanity address

A token address you choose to have a pattern, such as ending in "pump". You make it yourself with a key tool.

## Trading

#### Bag

The tokens you still hold of a token. Its value is what they would bring if you sold them now.

#### Basis points

Hundredths of a percent. 100 basis points is 1 %.

#### bps

Short for basis points. 100 bps is 1 %, so 300 bps is 3 %.

#### Bundle

Several transactions sent together so they land in the same block, in order, or not at all.

#### Cashback

Part of the trading fee paid back to the trader on some coins. You claim it from the Wallets page.

#### Jito bundle

Up to 5 transactions sent together through Jito. They land in the same block, in order, or none of them land.

#### Jito tip

A small extra payment that asks the network to put your bundle in a block quickly.

#### KOL

A well-known trader whose wallet people watch. In the app, any wallet on your Tracker list.

#### Limit order

An order that waits until the price reaches a number you pick, then buys or sells.

#### Liquidity

The money in a token's pool that buyers and sellers trade against. More liquidity means prices move less per trade.

#### Market cap

What all of a token's coins are worth together at the current price, in US dollars.

#### P&L

Profit and loss: how much you made or lost.

#### PnL

Profit and loss: what your trades made or lost. Often written P&L.

#### Pool

The place on the chain where a token is traded against SOL or another coin. Its price comes from what is in it.

#### Position return

What you sold, plus what your remaining tokens would sell for now, minus what you spent.

#### Price impact

How much your own trade moves the price. Big trades in small pools get a worse price.

#### Priority fee

An extra fee you add to a transaction so it gets into a block sooner.

#### PumpSwap

pump.fun's trading pools, where tokens trade after they leave the bonding curve.

#### Slippage

How far the price may move between your click and your trade. If it moves more, the trade is refused.

#### Stock token

A Solana token that follows the price of a real company's stock, such as NVDAx or TSLAx.

#### Stop-loss

A rule that sells early when a token drops a set percent below what you paid.

#### Take profit

A sell that happens when the price rises to a goal you set, to lock in a gain.

#### Volume

The total value of a token's buys and sells over a period, such as 24 hours.

## Tasks & automation

#### DCA

Dollar-cost averaging: buying or selling the same amount on a timer, so you get an average price over time.

#### Ladder

A row of limit orders at evenly spread levels, so you buy or sell a part at each level.

#### Launch task

A task added in the Create Project wizard. It can start the moment your token exists.

#### Mirror

A task that answers other people's trades on your token: it sells when they buy, or buys when they sell.

#### Supply plan

A saved list of how much of a token's supply each wallet should buy, in %.

#### Task

A job the app runs for you, such as buying, selling or making volume, over many wallets or over time. It keeps running on our servers after you close the window, until it finishes or you stop it.

#### Task preset

A saved set of task settings. Load it in the New task form to reuse the same settings.

#### Trailing stop

A sell level that follows the price up and sells when the price drops a set percent from its highest point.

## Account & fees

#### Fee tier

Your level for platform fees. The more fees you have paid in total, the higher your tier and the lower your rate.

#### Network fee

The small fee the chain charges for every transaction. It goes to the network, not to us.

#### Platform fee

The fee VortexDeployer takes on each buy and sell made in the app. Its rate depends on your fee tier and gets smaller on higher tiers.

#### Referral code

Your own short code for inviting people. It is the last part of your invite link.

#### Tier

Your account level. Higher tiers unlock more features and pay a lower platform fee.

## API

#### Access token

A short-lived code an OAuth app sends instead of an API key. On VortexDeployer it starts with vdo_, lasts 1 hour and acts as the API key it was tied to.

#### API key

A secret code that lets your own program use your account through the API. Treat it like a password.

#### Base units

The smallest unit of a coin or token, as a whole number. 1 SOL is 1,000,000,000 lamports; a token with 6 decimals has 1,000,000 base units per token.

#### Bearer token

A secret sent in the Authorization header as "Bearer <token>". Whoever holds it can use it, so keep it hidden.

#### Idempotency key

A name you choose for one operation and send with it. If you send the same call again with the same name, the API returns the first answer instead of doing it twice.

#### MCP

Model Context Protocol: a standard way for AI assistants such as Claude to call outside tools. VortexDeployer's MCP server turns each API call into a tool.

#### OAuth

A standard way for an app to get access to your account without seeing your password. You approve it once, and it gets a token.

#### OpenAPI

A standard file format that describes every call of an API, its fields and its answers. Tools can read it to build a client for you.

#### PKCE

Proof Key for Code Exchange: an OAuth step where the app proves, with a secret it made, that it is the same app that asked for access.

#### Rate limit

A cap on how many calls you may make in a set time, such as 300 a minute. Go over it and you must wait.

#### Refresh token

A longer-lived OAuth code that gets a new access token when the old one runs out. On VortexDeployer it starts with vdr_ and works once.

#### Request key

A UUID you make for one Wallet Marketplace order made through the API. Send the same one again and you get the same order back, not a second one.

#### Restricted key

An API key with limits on it: a max per buy, a daily cap, a wallet list or sandbox mode. Some actions need a key with no limits.

#### Scope

A permission on an API key, such as read, trade, launch or stream. A key can only make the calls its scopes allow.

#### Trace id

A code that names one API call in our logs. Send it to support when you ask about a call.

#### WebSocket

A connection that stays open, so the server can send you news the moment it happens.

---

# Best practices

> Habits that save money and avoid the most common failed launches, trades and transfers.

Source: https://vortexdeployer.com/docs/other/best-practices · Markdown: https://vortexdeployer.com/docs/other/best-practices.md

These tips come from real problems users have hit. Follow them and most failures never happen.

## Before you launch

- **Start small.** The app has no test mode. Try your first launch with a tiny [dev buy](https://vortexdeployer.com/docs/other/glossary#dev-buy) and few wallets. See [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run).
- **Leave SOL for fees in every wallet.** Buying wallets need the buy amount plus network fees. The [creator wallet](https://vortexdeployer.com/docs/other/glossary#creator-wallet) needs the dev buy plus about 0.03 SOL for fees and [rent](https://vortexdeployer.com/docs/other/glossary#rent).
- **Keep the name and symbol short.** pump.fun allows 32 bytes for the name and 10 for the symbol. Emoji and accented letters use more than one byte each.
- **Read the totals.** On **Review & Deploy**, check the line that adds up the dev buy and task buys. **Create** launches at once, with no extra confirm.
- **Choose permanent options with care.** On pump.fun, **Holder Rewards** cannot be switched back, and the **Custom-pair fee (%)** is final at launch.
- **Warm up new wallets.** [Wallet warm-up](https://vortexdeployer.com/docs/wallets/warm-up) gives new wallets a trading history with real trades on live pump.fun coins. It spends real SOL.
- **Use Fund to fill many wallets.** Sending straight from one wallet to many links them together on the chain. [Fund wallets](https://vortexdeployer.com/docs/wallets/fund) breaks that link. **Vortex Disperse** sends through in-between accounts. **Mixer** pays each wallet from an exchange, and the mixer service takes its own fee.

## While you trade

- **Keep SOL in wallets you will sell from.** A sale pays its network fee in SOL first. A wallet with no SOL cannot sell, even if it holds tokens.
- **Run one task per token and wallet set.** Two tasks on the same token with the same wallets can spend each other's tokens. Sales then fail or come out smaller than planned.
- **Read the task Preview when there is one.** Create the task without **Start immediately**, open **Preview** on its card, and press **Start** only when it looks right. Buy, Snipe, Migrate & Buy, Token Sender and Wallet warm-up have one.
- **Count the platform fee.** Every buy and sell pays it, including each trade of a volume task. See [Platform fees & tiers](https://vortexdeployer.com/docs/overview/fees).
- **Turn on Confirm Sell all** if you worry about pressing it by mistake. It is in **Account settings** → **Trading**.
- **Plan your exit.** One big sale moves the price a lot. The [Ladder](https://vortexdeployer.com/docs/tasks/ladder) task sells in parts at several market-cap targets. The [Trailing stop](https://vortexdeployer.com/docs/tasks/trailing-stop) task sells when the market cap drops a set percent from its peak.
- **On Robinhood Chain, wait for each transaction.** A wallet there sends one transaction at a time.

## When many launches fail at once

If several launches fail together with the same error, the launchpad may be changing its program. Wait a few minutes before you try again. Do not keep pressing **Create**. See [Troubleshooting](https://vortexdeployer.com/docs/other/troubleshooting).

## Getting your money out

:::danger Never collect straight to an exchange
Do not send funds from your wallets directly to an exchange such as Binance or Coinbase. Collect to a wallet you control first. Then send from there to the exchange.
:::

- **Check the address twice.** A collection cannot be undone.
- **Export keys before you delete wallets.** After you delete a wallet, you cannot export its [private key](https://vortexdeployer.com/docs/other/glossary#private-key) from the app any more. See [Export a private key](https://vortexdeployer.com/docs/wallets/key-export).
- **Use Close out when you are done with a project.** It sells what your wallets still hold and closes the empty token accounts to get the rent back. Then it collects the funds. It asks first. See [Close out](https://vortexdeployer.com/docs/launch/close-out).

## Keep your account safe

- **Never share a private key.** After you copy one, paste it into your wallet and clear your clipboard.
- **Plan password changes.** A new password cancels all your API keys. See [Sign in & accounts](https://vortexdeployer.com/docs/overview/sign-in).
- **Fund the wallet behind Copy deploy.** Each copy is a real launch paid by **Your deploy wallet**. If it has no SOL, every copy fails. Failed copies still count toward **Max per hour**.

## See also

- [Troubleshooting](https://vortexdeployer.com/docs/other/troubleshooting)
- [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run)
- [Start here: your first launch](https://vortexdeployer.com/docs/overview/quick-start)

---

# Troubleshooting

> How to find out what went wrong, and what to do about the most common messages.

Source: https://vortexdeployer.com/docs/other/troubleshooting · Markdown: https://vortexdeployer.com/docs/other/troubleshooting.md

When something fails, first find out what happened. Then look up the message below. Most messages say whether anything was sent. If it says nothing was sent, no funds moved.

## Check what happened

1. **The pop-up message.** Each trade shows a short message in the corner. A trade that landed has a **View tx** button. It opens the [transaction](https://vortexdeployer.com/docs/other/glossary#transaction) on the chain's explorer. A trade on many wallets shows a summary, such as "Bought on 3/5 wallets · 2 insufficient balance".
2. **The operation window.** Long jobs, such as funding or collecting, open in a window with their progress. It counts what has **Started**, what is **Queued** and what **Needs attention**. The job keeps running if you close the tab. Use **Check status**, **Stop remaining items** or **Continue remaining items**. See [Operation progress](https://vortexdeployer.com/docs/account/operations).
3. **The task card.** Open the token's terminal and find the task in the **Tasks** panel. **Executions** lists each step it ran. **Results** sums up what it did. See [How tasks run](https://vortexdeployer.com/docs/tasks/overview).
4. **Notifications.** The bell in the bottom bar keeps a list of recent events. See [Notifications](https://vortexdeployer.com/docs/account/notifications).

## Buying and selling

**"… this buy needs … plus fees; no swap was sent"** — The wallet holds less than the buy amount. Nothing was spent. Fund the wallet or buy less.

**"… cannot pay the network fee (a sale pays it in SOL before it runs); fund the wallet and sell again. No sale was sent."** — A sale needs a little SOL for its [network fee](https://vortexdeployer.com/docs/other/glossary#network-fee). Send some SOL to that wallet, then sell again.

**"These tokens are already reserved by pending sells. No additional sale was sent."** — An earlier sale of the same tokens is still running. Wait for it to finish, then check the wallet again.

**"Wallet holds none of this token; no sale was sent."** — That wallet has nothing to sell. Pick wallets that hold the token.

**"this wallet's previous transaction is still landing — nothing was sent; try again in a moment"** — Robinhood Chain only. A wallet there sends one transaction at a time. Wait a few seconds and try again.

**"… the amount is too small for the curve to return anything"** — pons only. The amount is too small to trade. Use a bigger amount.

**"Bought on 3/5 wallets · 2 insufficient balance"** — Some wallets did not have enough. Fund them and buy again with only those wallets.

**"Could not refresh. Showing the last saved data (…)"** — The numbers on screen may be old. Press **Retry now**.

## Launching

**The Create button is greyed out** — Its tooltip starts with "Missing:". Look under "Before you can launch, add:" and click each item. Each one ends in **Fix** and takes you to the field.

**"holds … SOL; a … SOL dev buy plus about 0.03 SOL of fees and rent needs about … SOL"** — The [creator wallet](https://vortexdeployer.com/docs/other/glossary#creator-wallet) is short. Fund it or lower the [dev buy](https://vortexdeployer.com/docs/other/glossary#dev-buy).

**"Name too long for the chain — pump.fun allows 32 UTF-8 bytes …"** — Emoji and accented letters count as more than one. Shorten the name. The symbol has the same rule with a limit of 10.

**"A transaction account does not have enough SOL for its transfer, rent or fees."** — One wallet in the launch is short. It may be a buyer, not the creator. Find the wallet in the failure details and fund it.

**"The dev buy exceeded its slippage — the curve moved."** — The price moved before the launch landed. Raise the dev-buy [slippage](https://vortexdeployer.com/docs/other/glossary#slippage), or try again.

**"The transaction expired before it landed (stale blockhash) — retry."** — The network was too slow this time. Try again.

**"The token's create and its …-routed dev buy are … bytes over one transaction …"** — This happens with a pump.fun coin as the pair. Shorten the name or symbol by the number of letters it gives, or launch with no dev buy. Nothing was sent.

**"launch: wallet … funding is still confirming."** — The wallet's funding has not landed yet. The app keeps it so the wallet is not funded twice. Wait a minute and press **Create** again.

**Several launches fail at once with an error that contains 3003** — This most often means pump.fun is updating its program. That takes a few minutes. Wait, then try again.

## Converting and copying

**"No supported direct SOL conversion pool with sufficient liquidity."** — There is no market with enough money in it to sell that token, so **Convert** cannot sell it. Leave it out of the conversion.

**"No supported route passed the safety checks. Price impact … exceeds your … limit"** — Selling that much would move the price too far. Convert a smaller amount.

**'Copy creation simulation failed: "AccountNotFound"'** — In **Copy deploy**, **Your deploy wallet** has no SOL. Each copy is paid by that wallet. Fund it. See [Copy deploy](https://vortexdeployer.com/docs/launch/copy-deploy).

**"Hourly deploy limit reached"** — **Copy deploy** reached your **Max per hour**. Failed attempts count too. Wait, or raise **Max per hour**.

## The app itself

**The bottom bar shows Offline or API down** — **Offline** means live updates have stopped. **API down** means the app cannot reach its server. Wait a moment, then reload the page. Before you repeat a trade, check whether the first one went through.

**Service unreachable** — The app cannot reach its server. Press **Retry**. See [Sign in & accounts](https://vortexdeployer.com/docs/overview/sign-in) for other sign-in messages.

## Still stuck?

1. Press **Help** in the bottom bar, or pick **Support** in your account menu.
2. Press **Contact support** or **Report a bug**.
3. Fill in the **Subject** and **Details**. Add the token, the wallet or task number, and the time it happened.
4. Press **Submit**. Replies show on the **Support tickets** page.

You can also press **Bug** in the bottom bar. It attaches details of the page you are on.

## See also

- [Best practices](https://vortexdeployer.com/docs/other/best-practices)
- [Real funds & confirms](https://vortexdeployer.com/docs/overview/dry-run)
- [Support](https://vortexdeployer.com/docs/account/support)