Opening connection…
Why that number is the pointA ticker that works is cloned in a minute. Find the contract the money is actually on.
Open the checkerArmed from the stream, checked against every pair already trading the symbol, signed by a seat.
Every other pad starts at the pair. This one starts at the post. No key? gk_test_sandbox opens the free one.
The pad · Which one is real · Docs · The gap · Sandbox · Pricing · Access
That clock is not a slow page. That is the pair — and the pair is the second thing that happens. The post came first, and a seat is handed the post.
Trackers report a post once it has been indexed. Grokinal is handed it on an open connection. There is no interval between the post and you, because there is no request.
Not a scraper pointed at X and not a bot reading a timeline. The launchpad runs on the X API itself — the same pipe the platform runs on. Nothing sits in between to be late.
Being early is worthless if you then go somewhere else to deploy. The signal and the deployer are the same surface: the ticker is filled before you have finished reading why.
A pair is what is left after a post has already worked. They find out the way you do — something trends, someone screenshots it, the deploy comes after. Grokinal is handed the post at the source, so the launch happens on the way up rather than in the reply guy's wake.
Measure what reacting costsA scraper has a page to load. A tracker has an interval to wait out. A bot has a timeline to read. Running on the X API removes all three — the post reaches the deployer without passing through anything that can be late.
The model sits on the raw stream, not on a summary of it. Narrative, account, engagement curve, first reply — evaluated at the source, and the deployer is already filled in by the time you have made up your mind.
Open the free sandboxThe stream carries a fixed number of concurrent connections, and a seat is one of them. The cap is not a pricing tier — it is the reason the edge survives contact with the people using it.
See the seat registerTracker, take and deployer on one surface. Others ship this as a video. Here it is running — with the authors masked, because the identities are the part a seat pays for.
Pick a signal in the feed. The deployer arms itself from it — you are reading the take with the launch already filled in.
Deploy is disabled on a preview key.
Take it to the padSelect a signal to get the take.
Tickers, pair counts and liquidity are read live from DexScreener. Authors, post bodies and timing are masked until a seat is issued — we will not print a stranger's post as if we had it.
The pad fills itself from the signal and checks the ticker against the live market before it will sign. Everything below is computed from the curve terms printed next to it.
The pad checks this against every pair DexScreener can see.
A preview key composes. A seat signs.
0.00 of 85 SOL raised · migration burns the LP
None yet. The pad has not signed a launch, so this board is empty rather than seeded. Every launch that happens here will be listed with the post it was armed from and a DexScreener link — nothing else.
The collision check is a live read of DexScreener. The numbers above are arithmetic on the curve terms printed beside them — no estimate, no projection, and nothing about a launch that has not happened.
A ticker that works gets cloned inside a minute, and the loss is always the same shape: the right name, the wrong contract. Type the symbol and this lists every Solana token trading under it, ranked by where the money actually is.
Read live from DexScreener at the moment you pressed check. Liquidity, volume and counts are summed across every pool for that token. This says where the flow is and which one existed first — it is not a safety verdict, and a contract being older does not make it good.
What the pad is, what the connection is worth in milliseconds, every field a seat unmasks, and every endpoint on this box — with a button next to each one that runs it against the live upstream while you read.
Every launchpad on Solana is a subscriber to the same thing: the consequences of a post. Grokinal subscribes to the post.
A trend is a chain with a fixed order. Someone writes something. It gets traction. A tracker indexes the traction. A deployer reads the tracker. A pair appears. The pair is the fifth link in that chain, and every launchpad in this market starts at link five — which is why the same twenty tickers get deployed within ninety seconds of each other by people who all believe they were early.
Being handed link one is a different business. The narrative is still being written when the composer is already filled: ticker, name, the account, how fast the first reply came. Not a prediction of what will trend — the raw material trending is made of, before the market has priced the fact that it exists.
That is the entire product. The tracker, the take and the gap demo are not features; they exist to show you the size of the head start and to prove the parts we can prove. The pad is where the head start gets spent.
An edge that everybody holds is a queue, not an edge. That is why the stream carries 250 seats and no overflow tier — not as a pricing ladder, but because the thing being sold stops working if it is sold twice as often. When the last seat is issued, the answer is a waiting list, not a bigger plan.
Trackers poll. A poll is a request you make on a schedule, and between two requests you are looking at a photograph of the past. The connection this pad is built on is the opposite shape: it is opened once and left open, and posts arrive on it as they are written.
Grok sits on that stream rather than on a summary of it, which is what makes the evaluation cheap enough to run on everything instead of on a shortlist. Narrative, account age, engagement curve, first reply — read at the source, scored, and pushed down the same open connection to the seats holding it.
| Design | Interval | What you see between events |
|---|---|---|
| Scraper on a page | page load + parse | the page as it rendered |
| Tracker on a poll | fixed, 1–15s | the last response |
| Bot reading a timeline | timeline refresh | an algorithmic ordering |
| Open connection | none | there is no between |
The row that matters is the last column, not the first. Shortening an interval moves a number. Removing the interval removes the shape.
A seat does not drink the whole firehose. It subscribes to rules, and a rule is a filter evaluated at the source rather than in your client — traffic you did not ask for never reaches you, so it never costs you time.
| Rule | Matches | Typical use |
|---|---|---|
account | posts from a set of handles | the twenty accounts that actually move things |
cashtag | a symbol written as $TICKER | watch a symbol before it has a pair |
keyword | phrase match with proximity | a narrative before it has a name |
velocity | engagement slope over a window | catch the curve, not the post |
first_reply | time to first reply under a threshold | the cheapest signal that a post landed |
Rules compose with and / or, and every signal carries the rule that matched it — so a seat can tell which of its rules is earning and which is noise.
Rule sets are specified, not live. Nothing on this site evaluates a rule today, because the connection they would run on is not connected — see status.
Numbers we measured on this box are marked measured, and you can re-run them from this page. Numbers that depend on the live X connection are marked specified, because the connection is not live yet and we are not going to print a figure we have not seen.
| Hop | Budget | Basis |
|---|---|---|
| Post written → pushed to the stream | < 1s | specified |
| Grok reads and scores the post | < 400ms | specified |
| Signal → composer filled | 0ms | measured same surface, no request |
| This box → DexScreener and back | 20–150ms | measured run it |
| A polled tracker on a 5s interval | 5,000ms blind per cycle | measured run it |
The third row is the one people miss. A tracker that reports in 200ms still hands you a ticker you then have to type somewhere else. The pad is filled by the same event that produced the signal, so the interval between knowing and acting is not small — it does not exist.
Thirteen fields. Six are public market data and are returned to any key, including the free one. Seven are the post itself, and those are what a seat is buying — the sandbox returns them masked so you can see the shape before you pay for the values.
| Field | Type | Free key | What it is |
|---|---|---|---|
ticker | string | returned | symbol on the youngest matching pair |
pair_age_min | int | returned | minutes since the pair was created |
liquidity_usd | int | returned | pooled liquidity, USD |
buys_5m | int | returned | buys in the last five minutes |
ticker_collisions | int | returned | exact symbol matches already trading |
profiles_scanned | int | returned | how many profiles the read covered |
post_id | string | masked | the post the signal came from |
author | string | masked | the account that wrote it |
author_age_days | int | masked | account age — the cheapest lie detector there is |
narrative | string | masked | what Grok read the post as being about |
first_reply_ms | int | masked | time to the first reply |
velocity | float | masked | engagement slope at read time |
actionable_until | timestamp | masked | when the head start is spent |
We mask rather than fabricate. No preview surface on this site prints a post body, an account name or a timing figure we do not hold — the sandbox shows exactly which values are withheld and returns the six public ones with a verify link.
A launch on this pad is a constant-product bonding curve against virtual reserves, one collision check, and a signature. The terms are constants, not policy that moves — they are printed on the composer next to the arithmetic they produce.
| Term | Value |
|---|---|
| Total supply | 1,000,000,000 |
| Sold on the curve | 800,000,000 |
| Virtual reserves | 30 SOL / 1,073,000,000 |
| Migration threshold | 85 SOL raised, LP burned |
| Trade fee | 1% — 50 seat · 30 pad · 20 seat pool |
| Opening market cap | 28.0 SOL at a zero dev buy |
Tokens returned for a dev buy of s SOL, where k is the product of the virtual reserves:
k = 30 × 1,073,000,000
tokens = 1,073,000,000 − k / (30 + s)
spot = (30 + s) / (1,073,000,000 − tokens)
mcap = spot × 1,000,000,000At s = 1 that is 34,612,903 tokens, 3.46% of supply, and a market cap of 29.9 SOL. The composer runs this arithmetic live and shows its work; nothing is rounded in your favour.
The same read, in full, is which one is real — the tool that answers the question a cloned ticker actually raises: which contract is the flow on.
Before it signs, the pad reads DexScreener for the ticker and counts exact symbol matches — a substring is not a collision. It does not veto. It tells you what already trades under that symbol, how much of it is on Solana, and how big the largest one is, with a link. A pad that hides that is selling you a chart nobody will believe.
The stream carries a fixed number of concurrent connections. A seat is one of them, held for as long as you hold it.
SIGN_REFUSED. The signature is the line between the two.| Limit | Value | Why it is that number |
|---|---|---|
| Concurrent connections | 250 | one per seat; the cap is the product |
| Rules per seat | 25 | enough to be specific, few enough to stay fast |
| Signals per rule | unmetered | a rule you wrote is traffic you asked for |
| Sandbox calls | 60 / hour | free, and it reads a live upstream |
| Seats per handle | 1 | asking twice does not move you |
The only limit enforced by code today is the last one — the register rejects a duplicate handle. The rest are the terms a seat is issued under.
Everything below runs right now, on the free key, against live upstream data. The last step is the only one that does not.
gk_test_sandbox opens the sandbox. It runs the same call a live key runs and returns the same shape.SIGN_REFUSED, on purpose, every time.These are the endpoints this box actually serves. Every one of them is live right now — press run and read the response you get, not the one we transcribed.
/api/feedThe signal feed: the eight youngest Solana profiles DexScreener will show, resolved to their deepest pair. Real tickers, real liquidity, X side masked.
press run/api/newestThe single youngest pair plus the server clock, so the late clock on the front page can tick against a timestamp instead of a guess.
press run/api/sandboxWhat the free key returns: six public values, our own measured latency_ms, and the list of fields a seat unmasks.
press run/api/collision?ticker=Exact symbol matches already trading, the Solana subset, and the largest pair by liquidity. This example asks about WIF.
press run/api/check?ticker=Every Solana token trading that exact symbol, pools summed per contract, ranked by 24h volume — with the address taking the flow and the address that existed first. Behind which one is real. This example asks about TRUMP.
press run/api/seatsThe register, read off disk: seats issued, seats total, requests on file. It answers 0 until it is not 0.
press run/api/pollOne upstream poll, used by the gap to time how long a polled source leaves you blind.
press run/api/seatWrites an X handle to the register. One row per handle; asking twice returns the position you already had. Not runnable from here — it writes.
curl -X POST http://localhost:5241/api/seat \
-H 'content-type: application/json' \
-d '{"handle":"yourhandle"}'Every refusal on this site is a specific string, because "something went wrong" is how you hide that you did not check.
| Code | Where | Means |
|---|---|---|
SIGN_REFUSED | the pad | a preview key composed a launch; a seat signs it |
DEPLOY_FORBIDDEN | terminal deployer | same line, drawn at the deployer |
INVALID_KEY | key gate | well-formed key, not on the seat register |
INVALID_HANDLE | /api/seat | an X handle is 1–15 characters, letters, numbers, underscores |
MALFORMED_BODY | /api/seat | body was not JSON |
WRITE_FAILED | /api/seat | the register could not be written; nothing was recorded |
TICKER_TOO_SHORT | /api/collision | fewer than two characters to check |
UPSTREAM_UNAVAILABLE | any live read | upstream did not answer; nothing is shown in its place |
The bullish case does not need help from a status page that lies. Here is the honest split, and it is the same split the surfaces show.
| Part | State |
|---|---|
| Market reads — feed, newest pair, collision, poll, sandbox | live real DexScreener data, running now |
| The gap measurement | live real requests, timed in your browser |
| Curve arithmetic on the pad | live computed from printed constants |
| Seat register | live writes to disk, opens empty |
| X / Grok stream | not connected the seven masked fields have no values yet |
| Signing and deploying | not built every sign path refuses on purpose |
| Seats issued | none the register is empty and the board is empty |
If a surface here ever shows you a post body, an author or a launch, it will be because the connection is live — not because the copy got braver.
Request a seatA polled source is only correct for the instant it arrives. The rest of the interval, you are looking at the past. This runs a real poll loop against a live public endpoint and counts the part where you were blind.
Upstream is api.dexscreener.com/token-profiles/latest/v1 — a real endpoint, polled for real. The interval is the point, not the endpoint.
The test key runs the call for real. What comes back is what is already public — timed against our own clock. The X side is masked, because the X side is what a seat pays for.
GET /api/sandbox — press run.Seven values are withheld. They are the post itself: who wrote it, when, and how fast the reply came.
The public half of this response is checkable — the source link appears with the pair it read.
Request a seatThe stream carries a fixed number of concurrent connections. A seat is one of them, held for as long as you hold it.
Reading the register… When the last seat is taken, the queue is the product. There is no overflow tier.
See what a seat returns firstA seat is one of the concurrent connections the stream carries. There are 250, and there is no tier above them — the cap is what keeps the edge worth holding. Everything that can be free is free.
Free
No key needed. Nothing to cancel.
2 SOL/ month
250 exist. When they are gone, the answer is a queue.
18 SOLone-time
The first 50 seats issued. Then never again.
Every trade on a launch made here pays 1% on the curve. It is split three ways, and the split is a constant — not a policy that moves once volume shows up.
A founding seat takes 60 and the pad takes 20. The pool is unchanged either way — the terms are printed on the composer next to the arithmetic they produce.
No seat has been issued. The register opens empty and says so, the board of launches is empty because nothing has launched here, and the X connection is not live yet — the seven fields have no values today. These prices are what a seat costs when the register opens, published now so nobody has to ask. Nothing is charged before then, and requesting a seat charges nothing at all.
Put a handle on the register