The basics

ZEZYX runs your code as a deployment — one process living on our servers. It can be a bot, an API, a background worker, or a terminal session.

Every deployment gets its own workspace, encrypted environment variables, streaming logs, and a supervisor that restarts it if it crashes.

Creating a deployment

1. Open Dashboard → New deployment
2. Pick a starting point: an official template, a Web3 tool turned into a bot, a blank project, pasted code, a Git import, or a marketplace listing
3. Set the name, type, runtime and visibility
4. Fill in any environment variables it asks for
5. Press Deploy

The process starts immediately. Watch the Logs tab to see its output live.

Deployment types

Free plan & limits

The free plan includes three always-on deployments. Everything else is included: the full terminal, every Web3 tool, the AI agent, Telegram and Discord hosting, private messaging on COTI, and the marketplace.

One per account is what makes "always on" sustainable — your process holds real memory on a real machine every second of the day. When you want to build something else, delete the deployment you have and the slot frees up instantly. If you need several at once, the Builder and Studio plans raise the limit.

Environment variables

Open a deployment → Environment. Values are encrypted at rest (AES-256-GCM) and only decrypted when the process starts.

// Node.js
const token = process.env.TELEGRAM_BOT_TOKEN;

# Python
import os
token = os.environ["TELEGRAM_BOT_TOKEN"]

ZEZYX API keys, included

You do not need to sign up with eight data providers to build something. Unless you set your own value, we inject ours — shown in the dashboard as ZEZYX:

COTI_RPC, COTI_CHAIN_ID, COTI_EXPLORER, COTI_ONBOARD_CONTRACT, EXA_API_KEY, COINGECKO_KEY, PINATA_JWT, FINNHUB_API_KEY

Set your own variable with the same name and yours wins. Turn the whole thing off with the switch on the Environment tab.

Your own platform key

Every deployment also gets ZEZYX_API_KEY and ZEZYX_API_URL, scoped to that deployment. With those your code can run every Web3 tool through our API without any third-party account:

const res = await fetch(`${process.env.ZEZYX_API_URL}/tools/coti-wallet-scan/run`, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: `Bearer ${process.env.ZEZYX_API_KEY}`,
  },
  body: JSON.stringify({ input: { mint: 'DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263' } }),
});
const { data } = await res.json();
console.log(data.result.summary);

Always available: PORT, TZ (UTC), ZEZYX, ZEZYX_DEPLOYMENT_ID, ZEZYX_DEPLOYMENT_NAME, ZEZYX_TYPE.

Telegram bots

ZEZYX never creates a bot for you — the bot is yours, we just keep it running.

1. Open Telegram and message @BotFather
2. Send /newbot and follow the prompts (a name, and a username ending in bot)
3. Copy the token, which looks like 123456789:AAF-xxxxxxxx
4. In ZEZYX: Dashboard → Telegram bots → + Add bot
5. Paste the token, choose which deployment it belongs to, save

We verify the token with Telegram, store it encrypted, and inject it as TELEGRAM_BOT_TOKEN. The deployment restarts automatically.

Turn a tool into a bot

Any Web3 tool can become a Telegram bot that belongs to you. Open Tools, pick one, and press Deploy as my Telegram bot.

We generate the complete source into your workspace — index.js and a README you can read and edit. The bot calls the ZEZYX tool API using the key we inject, so the only thing you supply is a BotFather token.

You can lock some inputs when creating it. A rug-check bot with the mint locked always scans that one token; leave it open and whoever chats with the bot supplies the address.

User: DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263
Bot:  Rug Check Scanner
      Bonk — High risk (risk score 96)
      Verdict          High risk
      Mint authority   Revoked
      LP locked        0.0%

Web apps

A web deployment gets an internal port and a public URL:

https://your-domain.com/live/<username>/<deployment-slug>/

const http = require('http');
const PORT = Number(process.env.PORT || 8080);

http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ ok: true }));
}).listen(PORT, '0.0.0.0');

Terminal

The terminal gives you a real shell inside your own account, with your deployment's environment loaded.

• General shell: Dashboard → Terminal — your home, with apps in ~/apps
• Per-deployment shell: open a deployment → Terminal tab

The prompt looks like this — your username, your path, nothing about the machine underneath:

$ yourname ~/apps/my-bot

Sessions close automatically after 30 minutes idle. Up to 3 at a time per account.

Import from Git

Pick Import Git when creating a deployment. We shallow-clone a public repo, skipping node_modules, .git, and files over 512 KB.

If there is a package.json we run npm install, and use npm start when a start script exists.

Web3 tools

24 tools running on our servers. No API key of your own required.

AI agent

Two modes:

• Plain chat — question and answer, backed by web search
• Agentic — the agent picks and runs tools itself, then answers with real numbers

Is this token safe? DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263
What is happening on COTI right now?
Has 0x… onboarded its privacy key yet?
What is the PnL of GDfnEsia2WLAW5t8yx2X5j2mkfA74i5kwGdDuZHt7XmG?

Each tool the agent runs appears as a chip above the answer — click one to see the raw data behind it.

Community tools

Wrap an official tool with inputs already filled in and publish it under your own name.

1. Go to Tools → Built by the community → Publish a tool
2. Pick the base tool and lock whichever inputs you want fixed
3. Submit — once an admin approves it, everyone can run it

Selling & buying

Publish an agent and let other people deploy it in one click.

• Publishing: Dashboard → My listings → Publish code
• Pricing: set a price in COTI, or leave it at 0 to give it away
• Review: listings go through moderation before they appear
• OFFICIAL: the badge on listings built by the ZEZYX team — always free

COTI payments

ZEZYX acts as the middle man, and takes no fee:

1. The buyer approves one transaction to the platform wallet, carrying a reference memo
2. We check it once at confirmed commitment — that single check decides success or failure, so there is no waiting on repeated confirmations
3. On success the listing unlocks and the full amount is forwarded to the seller's payout address automatically

Both transactions are visible on chain: the incoming payment and the outgoing payout are linked to the order and shown with explorer links in your history.

API reference

Create an API key under Settings → API keys, then send it as a bearer token.

curl https://your-domain.com/api/deployments \
  -H "Authorization: Bearer gm_xxxxxxxxxxxx"

Example: run a rug check

curl -X POST https://your-domain.com/api/tools/coti-wallet-scan/run \
  -H "Authorization: Bearer gm_xxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{"input":{"mint":"DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263"}}'

Wallet sign-in

ZEZYX detects every EVM wallet installed in your browser: MetaMask (pair it with the COTI Snap to hold private tokens), Rabby, OKX, Coinbase, Trust, Bitget and Brave. Signing in is a single personal_sign — no transaction, no gas.

The flow: you pick a wallet → the server sends a challenge containing a single-use nonce → your wallet signs it → the server verifies the ed25519 signature.

A wallet we have never seen does not silently become an account. You choose a username first — it is how people find your profile, your listings, and anything you deploy publicly. The wallet you signed in with is also set as your default payout address.

One account can link several wallets under Profile → Connected wallets.

Isolation & privacy

Each account gets its own Linux user inside the host container. Files, processes and shells run as that user, so nobody can read or kill anyone else's work. Your home directory is private, and the shell prompt shows only your username and your path.

Deployments are private by default. Flip one to public and the feed on the home page shows its bot handle and your username — nothing else. Your code, environment variables and logs stay private either way.

FAQ

Why does my deployment keep crashing?

Check the Logs tab. The usual causes are a missing environment variable, dependencies that were never installed, or a hardcoded port where process.env.PORT is required.

How long does a deployment stay up?

As long as its status is running. If it crashes, the supervisor restarts it with increasing backoff, up to 10 times in a row.

Can other people see my code?

No, unless you publish it to the marketplace yourself.

Can I use npm or pip packages?

Yes. Add a package.json or requirements.txt to the workspace and restart with the reinstall option.

What happens to my bot if I delete the deployment?

The process stops and the files are removed, but the bot itself still belongs to you in Telegram — the token keeps working and you can host it again any time.