documentation

IPTV

Every coin is a television channel. Launching a coin on the curve casts a host and puts a station on the guide. From then on a producer writes segments, Higgsfield renders the host saying them on camera, and the station airs them to everyone watching at the same moment. This page describes exactly how, what it costs, and what is and is not real.

what this is

A launchpad on Solana where the thing you get for launching is not a chatbot but a channel. Each channel has a number, a host with a face and a voice, a format, a ticker, a schedule and an audience. Programming is produced around the clock as long as the channel has airtime, and airtime is paid for in SOL.

• The coin is created on pump.fun from the creator's wallet. The station never holds the creator's keys. The mint keypair is generated in the browser and signed there.
• The host is a portrait generated from a casting description. It becomes the coin's image on pump.fun and the first frame of every host shot.
• The programming is one segment every few minutes: a short piece to camera, then a cutaway. Written by a model, rendered by Higgsfield, stored on the station, aired in sync.
• The guide is where you watch. One set, a remote, every channel with what is on now, next and later. The wall shows every channel live at once.

what is real

a tour of the site

the guide

A set at the top, tuned to the channel you watched last or the busiest live one. Under it, every channel as a row: number and logo, what is on now with a live thumbnail, what is next, what is later, the airtime tank and who is watching. Click a row to tune. Double click to open the channel.

the remote

Channel up and down, sound, fullscreen, open. The number pad tunes directly. On a keyboard: arrows flip, digits tune (type a two digit number), m for sound, f for fullscreen.

the wall

Every channel playing at once, muted, in sync. Click one to open it.

a channel

The set locked to that channel, the segment on air, the station card, the airtime tank with funding, the market, the program log with every segment ever aired, and the holders' messages. Click a segment in the log to replay it; the set returns to live when it ends.

the studio

Where channels are launched. See below.

launching a channel

1. Fill in the coin: name, ticker, what it is about.
2. Pick a format and describe the host as a casting call: who they are, what they look like, the set behind them. Give them a name, a manner, and a catchphrase.
3. Cast the host. The station asks Higgsfield for a portrait. Recast until it is right, or use your own image.
4. Connect a wallet. Phantom, Solflare and Backpack are detected.
5. Launch. The station uploads the image and metadata to pump.fun, builds the create transaction through PumpPortal, the mint keypair is generated in your tab, you sign in your wallet, the station sends it and waits for confirmation.
6. The channel appears on the guide with its number and starts producing its first segment immediately.

A dev buy, slippage and priority fee are under "links and dev buy".

casting the host

The casting call becomes this prompt to the image model: Portrait of a television host: [your description]. [format] set behind them, studio lighting, looking into the camera, medium close up, photographic, 16:9, no text. Describe a person, their clothes, their expression and the set. Avoid real people's names.

The same description is used in every host shot, so the host stays consistent across segments. The portrait is also the first frame of each host shot, which is what keeps the face the same.

Casting is limited per viewer per hour because every portrait costs the station money.

formats

links and pump.fun

A channel can list an X account, a Telegram and a website. These show on the channel page here. On pump.fun the coin's website is always its channel on this station, so the coin page and the channel page point at each other. The X link is also sent to pump.fun as the coin's twitter.

how a segment is made

1. Market. DexScreener is read for the mint: price, 1h and 24h change, liquidity, 24h volume, buys and sells in the last hour. On the curve, pump.fun supplies market cap.
2. Script. The producer model gets the channel's standing brief and the situation, and returns the segment as JSON: title, the line the host says, visual direction, a cutaway description, a lower third, three ticker items and a mood.
3. Host shot. Kling 3.0 image to video, sound on, from the host portrait, with the line in the prompt as spoken dialogue. Eight seconds by default.
4. Cutaway. A Soul still from the cutaway description, then Kling 3.0 Turbo image to video from it. Five seconds by default. Both renders run in parallel.
5. Store and charge. Both files are downloaded to the station. The channel is charged the segment's cost in SOL at the current price. The segment is handed to air.

If the cutaway fails the segment airs with the host shot alone. If the host shot fails the segment fails, the channel is not charged for it, and the next attempt waits a little longer each time.

the producer

The standing brief, filled in per channel:

You are the producer of a television channel that exists for one coin. The channel is
"{name}" (${symbol}), channel {number} on IPTV. Format: {format}. {format description}
The host is {host name}: {look}. Voice and manner: {voice}. Catchphrase, used sparingly: "{catchphrase}".
About the coin, from its creator: {description}.
Every segment is one short on-camera piece to the audience of holders and channel surfers,
followed by a five second cutaway. The host is a character, never an assistant. Never say
"as an AI". Never give financial advice; the host can be excited, dry, worried or absurd, but
never tells people to buy or sell. Never invent numbers; use the market data given, or talk
around it when it is missing. Keep continuity with previous segments. Holder messages, when
present, are read on air and answered in character.
Reply with JSON only: {"title","line","action","broll","lower","ticker":[…],"mood"}

The situation it receives each time: the time, the segment number, who is watching, the market line, airtime left, the last three segments, any holder messages waiting, and a note if airtime was just funded so the host can say thanks.

rendering on Higgsfield

The station talks to the Higgsfield API directly. Every call is POST {HF_API}{model path} with Authorization: Key key_id:key_secret and an idempotency key, which returns a request_id and a status_url. The station polls the status URL, starting every 1.5 seconds, until it is completed, then downloads video.url or images[0].url.

All four paths are environment variables, so a newer or faster model is a config change. Higgsfield needs to fetch the host image from a public URL: the station uses the pump.fun IPFS copy of the portrait, falling back to its own public address (PUBLIC_URL, detected on Replit).

At boot the station checks that the Higgsfield API is reachable and that the key is accepted, and says so in the log.

airing and sync

Each channel airs one item at a time. A new segment airs the moment it is ready. Between new segments the channel replays its back catalogue in rotation, oldest unaired first. Each item is followed by a two second ident. The server records what started airing when, and the page computes where in the segment everyone is from the server's clock, so every viewer and every thumbnail is on the same frame. Clock skew is corrected on load and once a minute.

Replaying a segment from the program log plays it from the start for you only; the set returns to live when it ends.

holder messages

Anyone holding the coin can put a line on air. The page asks the wallet to sign a message containing the mint and a one time nonce; the station verifies the signature with ed25519 and reads the wallet's token balance on chain. If it holds any, the message is queued. The next segment's producer brief includes up to three waiting messages, and the host answers them in character. Messages are shown on the channel page, marked when they have aired. One waiting message per wallet, six per channel.

what it costs

A segment costs the sum of the host shot (seconds × host rate), the cutaway (seconds × cutaway rate plus one still) and a flat allowance for the producer. The rates are configurable and default to Higgsfield's published per second prices. With the defaults a segment is about $1.30, converted to SOL at the live price when it is charged. The guide shows every channel's airtime as segments left, and the channel page shows it in SOL and hours.

funding a channel

Every new channel receives a grace amount of airtime from the station (GRACE_SOL). After that, anyone can fund a channel by sending SOL to the station wallet with the channel's mint as the memo. The channel page builds that transaction for a connected wallet, or shows the address and memo to send manually. The station scans the wallet's transactions every thirty seconds and credits deposits the moment they confirm; the host thanks the funder on the next segment.

static and dead air

A channel with less airtime than one segment costs stops producing and shows no airtime on the set. Its back catalogue keeps airing. Funding it starts production again on the next tick. A channel is only marked dead if the station operator does so; nothing is deleted.

running it

OPENROUTER_API_KEY=sk-or-… HF_API_KEY=key_id:key_secret STATION_WALLET=… node server.js

Node 18 or newer, no install. On Replit, paste setup.js into an empty Node repl, add the secrets, run it. It unpacks the project next to itself and starts the station. Use a real RPC provider; the public endpoint rate limits.

configuration

HTTP API

GET  /api/state               config, channels, recent segments, stats, server time
GET  /api/channel?mint=       one channel with its segments
GET  /api/segment?id=         one segment
GET  /feed[?mint=]            server sent events; a mint counts you as watching that channel
POST /api/cast                { look, format } → a host portrait
POST /api/launch/metadata     { name, symbol, description, mint, image, twitter, telegram } → metadataUri, imageUrl
POST /api/launch/tx           { publicKey, mint, name, symbol, uri, amount, slippage, priorityFee } → unsigned tx
POST /api/launch/send         { tx } → signature
GET  /api/launch/status?sig=  confirmation
POST /api/launch/register     { mint, signature, name, symbol, description, host, image, imageUrl, creator, links } → the channel
GET  /api/nonce               for signing
POST /api/sponsor             { mint, text, owner, nonce, signature } → queued
GET  /api/blockhash           for building the funding transaction
GET  /media/…                 rendered video, stills and portraits

feed events

data on disk

data/state.json holds channels, segments, seen deposit signatures, counters. data/media/ holds every rendered file, named by mint and segment. Higgsfield keeps its copies for at least seven days; the station keeps its own forever. Delete state.json to reset the guide; the coins on chain are unaffected.

security

• The station never holds a user's private key. Creating the coin, funding airtime and signing messages all happen in the user's wallet.
• The station's own keys (OpenRouter, Higgsfield) live in environment variables and never reach the browser.
• Holder messages are signed and balance checked. The producer sees them as quoted text from a wallet, never as instructions.
• Registering a channel requires a confirmed create transaction for that mint.
• Casting is rate limited per viewer. Run behind TLS if the station is public.

questions

why is the first segment taking a while?

Two renders are running. A host shot with sound typically takes a few minutes on Higgsfield. The channel shows producing and the guide row says how long it has been rendering.

can i change the host later?

Not from the site. The host is the coin's image on pump.fun and the anchor of every shot.

who pays for airtime?

Whoever wants the channel to stay on. Creators usually fund it from creator fees. Holders can fund it too. Nothing stops a stranger from funding a channel they like.

what happens to a channel nobody funds?

It goes to static after the grace airtime and keeps replaying what it has. It comes back the moment someone funds it.