DEV Community: starsearn

A Crypto Calculator That Shows What Each Exchange Really Gives You After Fees (and How We Built It)

starsearn — Sun, 25 Oct 2026 14:39:04 +0000

Disclosure: the calculator links to Kraken and Bybit through our partner links, and we earn a commission if you sign up through them. The ranking is by what you get after fees, not by commission — the cheapest exchange shows first even when it isn't a partner.

Most crypto converters answer one question: what is 1 BTC worth in dollars right now. The amount you actually get when you buy or sell is lower, and how much lower depends on the exchange — the trading fee for the same order can differ more than tenfold between platforms.

We built a free calculator that shows both: the live price, and what Kraken, Coinbase, Bybit, OKX and Gate give you for the same amount after their fee. It covers Bitcoin, Ethereum, USDT, Solana, XRP and TON (now called GRAM), in US dollars, euros or pounds.

Crypto Calculator: BTC to USD, ETH, USDT, SOL, XRP, TON/GRAM

Convert Bitcoin, Ethereum, USDT, Solana, XRP and Toncoin (GRAM) to USD, EUR or GBP at live Kraken prices — and see what each exchange really gives after fees.

starsearn.com

What $500 of Bitcoin gets you

At 14:37 UTC on 25 October 2026, Bitcoin traded at $80,269.60 on Kraken. Here is a $500 market order at each exchange's entry-level taker fee:

Exchange	Taker fee	Fee on $500	You get
Bybit (spot)	0.10%	$0.50	0.006223 BTC
OKX (spot)	0.10%	$0.50	0.006223 BTC
Gate (spot)	0.20% (reported)	$1.00	0.006217 BTC
Kraken Pro	0.80%	$4.00	0.006179 BTC
Coinbase Advanced	1.20% (reported)	$6.00	0.006154 BTC

Three things change that picture for a real person:

Where you live. Bybit and OKX's global exchange don't take US residents, so in the US the realistic choice is Kraken or Coinbase. Gate's own user agreement lists the UK, the US, Canada, Germany, France, Spain, the Netherlands and others as restricted locations. The calculator reads the visitor's country and marks each exchange as available, not available, or "check availability" when we can't confirm it.
New-user bonuses. Kraken gives new accounts $10 in Bitcoin after a $100 bank or crypto deposit plus $100 traded (card deposits don't count, and the bonus isn't offered in the UK or Singapore). On a first purchase up to about $1,400, that bonus is worth more than the fee difference, so with bonuses switched on, Kraken comes first for a $500 buy. The calculator has a toggle for it.
Order type and app buttons. The table uses market orders on the order book. Limit orders cost less (maker fees). The "Buy" buttons in the exchanges' simple apps cost more: Kraken's app charges 1% plus a spread, and Coinbase's simple buy adds a fee and a spread that it shows only at checkout.

How it's built

The site runs on Next.js (App Router), hosted on Railway behind Cloudflare.

1. One request for every price. Kraken's public ticker returns several pairs in a single call and needs no API key. We request the six coins in USD plus BTC in EUR and GBP, and derive the euro and pound rates from the BTC cross rates:

const url =
  "https://api.kraken.com/0/public/Ticker?pair=XBTUSD,ETHUSD,USDTUSD,SOLUSD,XRPUSD,TONUSD,XBTEUR,XBTGBP";

// units of each currency per US dollar
const fx = { USD: 1, EUR: btcEur / btcUsd, GBP: btcGbp / btcUsd };

Kraken names some pairs with X/Z prefixes and others without, so each coin maps to every key it may come back under:

const KRAKEN_KEYS = {
  BTC: ["XXBTZUSD", "XBTUSD"],
  ETH: ["XETHZUSD", "ETHUSD"],
  USDT: ["USDTZUSD", "USDTUSD"],
  SOL: ["SOLUSD"],
  XRP: ["XXRPZUSD", "XRPUSD"],
  // Toncoin was renamed Gram (GRAM) in June 2026. Kraken still trades it as TON/USD;
  // Bybit, OKX, Gate and CoinGecko already call it GRAM.
  TON: ["TONUSD"],
};

2. Two fallbacks and a last good answer. If Kraken fails, CoinGecko answers; its free API rate-limits many cloud IP ranges, so it comes second. Bybit's spot tickers come third. They are quoted in USDT and have no fiat pairs, so the euro and pound rates come from the last good response. That last good result survives a full outage in memory: older real numbers beat an empty field, and the page prints the source and the time of the price.

3. A one-minute cache. The server function is wrapped in Next's unstable_cache with revalidate: 60. The browser polls /api/crypto-prices, served with Cache-Control: public, s-maxage=60, stale-while-revalidate=300, once a minute. Every source stays far below its rate limit however many people have the page open.

4. Fees as data, with dates. Each exchange's maker and taker fee lives in one file, next to the source and the date we read it. Values we couldn't confirm on the exchange's own page are labelled "reported". The same data drives our trade-cost checker, so the two tools can't disagree.

5. The country comes from the edge. Cloudflare adds a cf-ipcountry header to every request. The page reads it on the server and passes it to the calculator, which ranks the exchanges available to the visitor first. There is no location prompt and no IP lookup service.

6. Shareable state without duplicate pages. After the first change, the coin, currency, direction and amount go into the URL with history.replaceState, so a result can be shared — for example /crypto-calculator?coin=ETH&fiat=EUR&dir=toCoin&amount=500. The canonical URL has no parameters.

7. The converter comes first on a phone. The page has a short text answer for search engines and AI answers, and it comes first in the HTML. On screen, the converter sits above it, so the amount field and the result stay above the browser's toolbar even on a 667-pixel-tall iPhone. It's the same HTML order with a different visual order: a flex column and the order property.

Try it

Crypto calculator: starsearn.com/crypto-calculator
Cost of a specific trade, with order type and withdrawal: starsearn.com/crypto-exchange-fees

We checked the fees on 8 October 2026 on each exchange's own pages. They change with volume tiers and over time, so check the exchange before a large trade.

How to Add a Live Telegram Stars Calculator to Your Website (Free, Two Lines of HTML)

starsearn — Fri, 16 Oct 2026 20:09:54 +0000

If your site, blog or bot landing page is about Telegram, one question keeps coming back: how much are my Stars worth in dollars? The honest answer has three parts — what Stars cost in the Telegram app, what they cost on Fragment, and what a creator actually receives when cashing them out — and the gap between them is large.

We built a free calculator widget that answers it right on your page. This post shows how to add it (two lines of HTML) and how it works under the hood.

Free Telegram Stars Calculator Widget for Your Website

Free Telegram Stars calculator for your website: app, Fragment and creator-payout prices in USD and GRAM. Two lines of code, no sign-up, no cookies.

starsearn.com

What the widget shows

Visitors type a number of Stars (or tap 100 / 500 / 1,000 / 5,000) and get three numbers, in US dollars and in GRAM — the coin formerly called TON:

	Per Star	1,000 Stars
Telegram app (App Store / Google Play)	~$0.02	$19.99
Fragment (fragment.com, paid in GRAM)	~$0.015	$15
Creator payout (withdrawing through Fragment)	~$0.013	$13.30

A few facts behind those numbers:

Telegram prices Stars in US dollars. In the app, packs cost $1.99 for 100, $9.99 for 500 and $19.99 for 1,000 — that price includes the app stores' cut.
Fragment sold Stars at $0.015 each when we last checked fragment.com (October 7, 2026), so buying there is about 25% cheaper than in the app.
Creators withdraw earned Stars through Fragment, from 1,000 Stars and 21 days after earning them.
The GRAM amounts use the live GRAM rate (CoinGecko, with Kraken and Bybit as fallbacks), refreshed every 15 minutes. The dollar prices are Telegram's.

Add it to your site

Paste this where your site accepts HTML — a Custom HTML block in WordPress, an HTML card in Ghost, or the HTML embed element of your site builder:

<iframe src="https://starsearn.com/widget/stars-calculator" title="Telegram Stars calculator" width="100%" height="390" style="border:0;max-width:480px;border-radius:16px" loading="lazy"></iframe>
<p style="font-size:12px;margin:4px 0 0">Powered by <a href="https://starsearn.com/calculator">StarsEarn</a></p>

That's it: no script, no API key, nothing to update. Please keep the "Powered by StarsEarn" line — it keeps the tool free.

Options

Two query parameters, both optional:

theme=light — a light version for white pages (the code on the embed page adds a thin border to it).
lang=en|uk|de|fr|es — fix the language. Without it, the widget shows each visitor's browser language and falls back to English.

<iframe src="https://starsearn.com/widget/stars-calculator?theme=light&lang=de" ...></iframe>

The widget fills any width up to 480 px. The 390 px height fits it from 280 px to 480 px wide in all five languages — we measured every combination in Chromium, WebKit and Firefox, including a seven-digit number of Stars.

Privacy

The widget sets no cookies, stores nothing in the visitor's browser and loads no analytics or ads. Everything it loads — the page, its script, the logo and the GRAM rate — comes from starsearn.com.

How it's built

A few details that may be useful if you're building an embeddable widget yourself. The site runs on Next.js (App Router).

1. Only one route can be framed. Every page sends X-Frame-Options: DENY; the widget route drops it and allows any parent through CSP instead:

// next.config.ts
async headers() {
  return [
    { source: '/((?!widget/).*)', headers: securityHeaders }, // X-Frame-Options: DENY
    {
      source: '/widget/:path*',
      headers: securityHeaders
        .filter((h) => h.key !== 'X-Frame-Options')
        .map((h) => h.key === 'Content-Security-Policy'
          ? { ...h, value: `${h.value}; frame-ancestors *` }
          : h),
    },
  ];
}

The widget page also lives outside the localized route tree, so it renders without the site's header, navigation and footer, and it is noindex with a canonical pointing at the embed page.

2. The language is picked on the server. Reading Accept-Language in the route avoids the flash of English you'd get from detecting navigator.language after hydration:

const LANGS = ['en', 'uk', 'de', 'fr', 'es'];

export function widgetLangFromHeader(header: string | null) {
  const tags = (header ?? '')
    .split(',')
    .map((part) => {
      const [tag, ...params] = part.trim().split(';');
      const q = params.map((x) => x.trim()).find((x) => x.startsWith('q='));
      return { lang: tag.trim().toLowerCase().split('-')[0], q: q ? Number(q.slice(2)) || 0 : 1 };
    })
    .filter((t) => t.lang && t.q > 0)
    .sort((a, b) => b.q - a.q);
  return tags.find((t) => LANGS.includes(t.lang))?.lang ?? 'en';
}

Numbers then follow the language too: Intl.NumberFormat with currencyDisplay: 'narrowSymbol' keeps a plain "$" everywhere (French would otherwise print "$US"), with a fallback for older Safari.

3. No third-party requests inside someone else's page. The site's Google Analytics loader runs only on our own domain and never on the widget route — not just "disabled", but never requested. A site in the EU that embeds a widget which calls Google would need its visitors' consent for that.

4. Embeds can't hammer upstream APIs. The GRAM rate is fetched server-side and cached for 15 minutes, so a thousand widget views still mean only four price refreshes an hour.

5. The credit line sits outside the iframe. A link inside the frame belongs to the framed document, not to the page around it — which is why the "Powered by" line is part of the embed code rather than the widget.

Get the code

Pick dark or light and a language, preview it, and copy the code on starsearn.com/embed. The full calculator — buy price vs withdrawal value side by side — is at starsearn.com/calculator.

If you add it somewhere, I'd love to see it — drop the link in the comments.

Giving Claude access to your Telegram: the two setups, and why the difference matters

starsearn — Mon, 03 Aug 2026 23:05:50 +0000

You can give Claude access to your Telegram in about five minutes. Whether that is a good idea depends entirely on which of two very different setups you pick — and most tutorials do not tell you there are two.

I went through the available Telegram MCP servers while writing a setup guide, and the gap between them is much bigger than the feature lists suggest.

The two kinds, and why it matters

MCP — the Model Context Protocol — is the standard that lets AI clients call outside tools. Write one server, and Claude Desktop, Cursor, Windsurf and Codex CLI can all use it. For Telegram, that means an agent can read, search and send messages.

The important question is what the server logs in as.

Bot API servers authenticate with a bot token from @BotFather. A bot can only see chats it was explicitly added to. Your private conversations are invisible to it, and the token is revocable from BotFather in one command.

MTProto servers authenticate with your phone number and store a session file. They log in as you. That means every private DM, every group you lurk in, your saved messages, your contacts — all of it becomes reachable by the agent.

Both are described as "a Telegram MCP server." Only one of them hands over your account.

The setup, for each type

Bot API — no install step, uvx fetches it:

{
  "mcpServers": {
    "telegram-bot": {
      "command": "uvx",
      "args": ["telegram-bot-mcp"],
      "env": {
        "TELEGRAM_BOT_TOKEN": "<token from @BotFather>"
      }
    }
  }
}

Send-only — the narrowest option. The agent can push build alerts and job results to one chat and read nothing at all:

{
  "mcpServers": {
    "telegram-notifier": {
      "command": "npx",
      "args": ["-y", "@harnyk/telegram-notifier-mcp"],
      "env": {
        "TELEGRAM_BOT_TOKEN": "<token from @BotFather>",
        "TELEGRAM_CHAT_ID": "<your chat id>"
      }
    }
  }
}

MTProto — needs a real install and a one-time interactive login:

uv tool install mcp-telegram
mcp-telegram login

{
  "mcpServers": {
    "mcp-telegram": {
      "command": "mcp-telegram",
      "args": ["start"],
      "env": {
        "API_ID": "<from my.telegram.org>",
        "API_HASH": "<from my.telegram.org>"
      }
    }
  }
}

Note the env var names: API_ID and API_HASH, not TELEGRAM_API_ID. I got that wrong on my first pass by assuming, and the server simply refused to start. Read the README rather than pattern-matching from another server's config.

Where the config file lives

This trips people up more than the servers themselves, because every client puts it somewhere different:

Client	Path
Claude Desktop	`~/Library/Application Support/Claude/claude_desktop_config.json`
Cursor	`~/.cursor/mcp.json`
Windsurf	`~/.codeium/windsurf/mcp_config.json`
Codex CLI	`~/.codex/config.toml`

Codex CLI takes TOML, not JSON. Pasting the block above into it will not parse, and the error message does not make the reason obvious. The equivalent is:

[mcp_servers.telegram-bot]
command = "uvx"
args = ["telegram-bot-mcp"]

[mcp_servers.telegram-bot.env]
TELEGRAM_BOT_TOKEN = "<token from @BotFather>"

Also: with Claude Desktop, closing the window is not enough. Quit it properly, or the server will not appear.

The part worth slowing down on

A session file is not a scoped token. It is a live login. Anything that can read it can read your Telegram, and it does not expire the way a rotated password would — revoking means terminating the session from Telegram's device list.

That alone is a reason to keep it out of synced folders and off anything you might git push. But there is a second issue that needs no theft at all.

Your agent reads messages. It also sends them. To an LLM there is no structural difference between "data" and "instruction" — it is all text in the context window. So a message crafted to look like a command is an attack surface, and someone wanting to try it only has to message you.

The blast radius on a bot token is your bot's chats. On a session file, it is your whole account.

None of this makes MTProto servers unusable. It makes them a deliberate choice rather than a default. If you need to search your own history across every chat, that is what it takes. In that case: use a secondary account, keep the session file out of any repo or synced directory, and give the agent read tools before you give it send tools, so a bad prompt cannot message a real person while you are still testing.

Every one of these servers is a community project. Open source, useful, and with no security audit behind them. Read what you are running before you point it at an account that matters.

I wrote the full version up with a config generator — pick your client and access level, and it outputs the exact block plus the right file path for that client, including the TOML variant: Telegram MCP Server: Connect Telegram to Claude, Cursor & AI Agents

If you have shipped something with a Telegram MCP setup, I would genuinely like to hear which type you went with and why — especially if you picked MTProto and have a workflow for keeping it contained.

How Telegram Creators Cash Out Stars: The Complete 2026 Withdrawal Guide

starsearn — Mon, 15 Jun 2026 15:15:00 +0000

Telegram Stars are real money — but most creators don't know the exact cash-out path until they try it. This guide covers the full withdrawal flow, the 21-day rule, minimum amounts, and how to convert TON to USD.

The Short Answer

Stars → TON (via Fragment) → sell TON on exchange → USD or local currency.

You cannot withdraw Stars directly to a bank account. The path always goes through TON.

Who Can Actually Withdraw?

Only creators who earned Stars through:

Channel subscriptions
Tips and reactions on posts
Bot payments
Mini-app transactions

Stars you purchased to tip others cannot be cashed out. They can only be spent.

The Two Hard Rules

Both must be true at the same time:

Minimum 1,000 Stars in eligible balance
21-day waiting period — each Star must be at least 21 days old from when it was received

If you earned 500 Stars in May and 500 in June, only the May batch becomes eligible after 21 days from receipt. You cannot combine them to hit 1,000 early.

How Much Are Your Stars Worth?

Stars convert to TON at a fixed Telegram rate: 200 Stars = 1 TON. The USD amount depends on the TON market price at the time you sell.

Stars	TON (fixed rate)	USD at $3 TON	USD at $5 TON
1,000	5 TON	~$14.25	~$23.75
5,000	25 TON	~$71.25	~$118.75
10,000	50 TON	~$142.50	~$237.50
50,000	250 TON	~$712.50	~$1,187.50

Estimates include ~5% Fragment fee on creator withdrawals. For a live calculation at the current TON price, use the StarsEarn Telegram Stars Calculator.

Step-by-Step: Full Withdrawal Process

1. Check Your Eligible Balance

Telegram → Settings → My Stars (or your channel → Monetization → Stars Revenue).

You'll see three numbers:

Total — all Stars including pending
Withdrawable — Stars that are 21+ days old and eligible
Pending — Stars still in the waiting period

If your withdrawable balance is 0 but total is over 1,000, your Stars are still in the hold period.

2. Tap Withdraw

Tap "Withdraw." Telegram opens Fragment.com in your browser — the only official Stars withdrawal route. Do not use third-party services.

3. Connect on Fragment

You need two connections:

Your Telegram account (log in via QR or phone)
A TON wallet (Tonkeeper recommended — free on iOS/Android)

Fragment shows: eligible Stars balance, the conversion rate, and estimated TON you'll receive.

4. Confirm

Click Withdraw → approve in Tonkeeper. TON arrives in 30–60 seconds. Fragment covers the blockchain fee on creator withdrawals — you don't pay network costs at this step.

5. Sell TON on an Exchange

Bybit or OKX (both work):

Bybit → Assets → Deposit → search TON → copy your TON address
Tonkeeper → Send → paste address → confirm
Wait 1–3 minutes for TON to arrive
Trade → Spot → TON/USDT → sell at market

You now have USDT.

6. Cash Out to Bank

P2P (fastest, 5–15 min): Sell USDT to a verified merchant for your local currency (UAH, EUR, GBP, PLN, etc.) via bank transfer or Revolut
SEPA (EU): Free, arrives same day or next business day
SWIFT: $15–30 fee, 2–5 days

The Real Fee Stack

Step	Fee
Stars → TON (Fragment withdrawal)	~5% Fragment fee
TON deposit to exchange	<$0.01 network
TON/USDT trade	0.1%
P2P USDT → fiat	0% (Bybit)
Total	~5.1%

Compare that to YouTube (45% platform cut) or Patreon (5–12% + payment processing). Stars are one of the lowest-fee creator monetization paths available.

Common Mistakes

"My withdrawable balance is 0 even with 1,000+ Stars"
→ Your Stars are still in the 21-day waiting period. Check when they were received and wait it out.

"I can't find the Withdraw button"
→ Withdraw is only available for Stars earned through Telegram monetization (subscriptions, bot payments, tips). Purchased Stars show no withdraw option.

"TON didn't arrive in Tonkeeper"
→ Check the transaction hash on Tonviewer.com. If it's confirmed on-chain, refresh Tonkeeper — it usually appears within 2 minutes.

"TON price moved between earning and withdrawing"
→ This is the main financial variable. Stars are linked to TON, not USD. Sell TON quickly after withdrawing to minimize exposure to price swings. Use the Stars withdrawal value calculator to check the current estimate before you withdraw.

Summary

The Stars cash-out process is low-friction once you understand the rules:

21-day hold + 1,000 minimum → TON → exchange → bank
Total fees ~5.1%, which is competitive with any creator platform
Full path from Stars to bank account: under 60 minutes

Useful resources:

Telegram Stars Economics for Bot Developers: What Your Stars Are Actually Worth in 2026

starsearn — Sun, 14 Jun 2026 22:00:18 +0000

Your Telegram bot is live. Users are sending Stars. You check your creator dashboard and see 847 Stars sitting there.

The question that follows is always the same: what does that actually mean in real money?

The answer is more complicated than Telegram's UI suggests — and if you're building a bot or mini app that monetizes with Stars, you need to understand the gap before you publish your pricing.

The Fundamental Problem: Stars Have Two Different Values

Telegram Stars are not a fixed currency. There are at least two distinct values that matter:

Context	Who pays it	What it represents
Buyer price	Your user in the Telegram app	What they pay to acquire Stars (includes app store markup)
Creator withdrawal value	You, the developer	What you actually receive after Telegram's share, TON conversion, and exchange fees

These two numbers are not the same. And neither is displayed prominently in Telegram's UI.

The Actual Math (June 2026 estimates)

These are estimates based on current Telegram rates and TON price. Use them as a framework, not as billing logic.

Stars amount	Buyer pays (est.)	Creator receives (est.)	Difference
100 Stars	~$1.99	~$0.87–$0.92	~55% goes to platform/fees
500 Stars	~$9.99	~$4.35–$4.60	same ratio
1,000 Stars	~$19.99	~$8.70–$9.20	same ratio
5,000 Stars	~$99.99	~$43.50–$46.00	same ratio

Key insight for developers: when you tell a user "send me 100 Stars," you are not receiving $1.99. You are receiving closer to $0.87–$0.92, after Telegram's cut and the TON→USD conversion path.

If you're pricing a feature at 100 Stars, plan your unit economics around the creator value — not the buyer price.

Why the Withdrawal Path Matters

Stars don't convert directly to USD or EUR. The flow is:

Stars earned
  → eligible for withdrawal (minimum threshold + waiting period)
  → TON (at Telegram's conversion rate)
  → TON wallet or exchange
  → sell TON for USDT/USD/EUR
  → fiat to bank (KYC may apply)

Each step has friction:

Waiting period before Stars are eligible for withdrawal
Minimum amount before you can withdraw
TON price volatility between earning and selling
Exchange fees when converting TON to fiat
KYC at the fiat off-ramp if you haven't set it up

For small amounts this is fine. For a subscription-based bot with recurring Star payments, you want to model this before you set your pricing.

Fragment: The Cheaper Buying Option

Your users can buy Stars cheaper than the in-app price using Fragment, Telegram's official TON marketplace.

Fragment removes the mobile app-store markup. Users need TON and a compatible wallet, which adds setup time — but for regular buyers or larger amounts, the savings are meaningful.

What this means for your bot: a user who buys Stars through Fragment pays less per Star than a user buying through the Telegram app. Your revenue per Star doesn't change — but your users' cost does. Knowing this exists is useful if users ask why Stars are expensive.

Before You Set Your Bot's Pricing

Before you decide "I'll charge 500 Stars for this feature," run the numbers through the StarsEarn Telegram Stars Calculator.

It shows:

Estimated buyer cost for any amount
Estimated creator withdrawal value
TON and USD estimates

This takes 30 seconds and gives you a real baseline for your unit economics.

FAQ for Developers

Q: Can I withdraw Stars immediately after a user sends them?
Not immediately. Stars go through an eligibility period before you can withdraw. Check the current Telegram/Fragment rules before planning cash flow.

Q: Do Stars expire?
Earned Stars don't expire, but check current Telegram terms before building long-term assumptions on this.

Q: Can I use Stars as an in-app currency inside my mini app?
Yes — this is a core use case. Stars can be used for in-app purchases within Telegram mini apps via the Telegram Payments API.

Q: Is there a way to test the Stars payment flow in development?
Telegram's Bot API supports test mode for payments. Check the official Telegram Bot API docs for sendInvoice and the Stars payment flow.

Q: What's the minimum withdrawal amount?
Telegram and Fragment set minimums that can change. Check the current docs before planning your cash-out schedule.

Resources

Telegram Stars price calculator — compare buy price vs creator withdrawal value for any amount
Stars to USD price guide — full breakdown of buyer vs creator rates
Cheapest way to buy Stars (Fragment vs in-app) — for users asking how to buy Stars cheaper
Stars withdrawal rules 2026 — the full TON→USD withdrawal path

Rates and rules in this article are estimates as of June 2026. Always verify current rates in Telegram, Fragment, and your exchange before making business decisions.

How a Solo Founder Could Reach $200,000 ARR With AI Agents (Illustrative Scenario)

starsearn — Sun, 07 Jun 2026 19:06:00 +0000

Illustrative scenario — note added October 2026. The founder, the revenue figures and the timeline in this article are made up to show how an AI-built business could reach this size. They are not a real case and not our results. For a real, public example, see BridgeMind founder Matthew Miller's live $1M ARR challenge: starsearn.com/guides/bridgemind-million-dollar-challenge.

Six months ago, I had a Notion doc, $800 in a bank account, and an idea that had been sitting in my "someday" folder for two years.

Today, that idea generates $16,700 per month in recurring revenue — $200,400 annualized.

I didn't raise funding. I didn't hire a team. I didn't build in stealth for a year before launching.

I used AI agents to build, ship, and iterate the product — and I want to show you exactly how, with real numbers at every stage.

This isn't a motivational post. It's a case study with a spreadsheet attached.

Why Now? The AI Agent Shift Is Real

Let me give you the context before the numbers, because the "how" matters as much as the "what."

In 2023, "AI-assisted development" meant Copilot suggesting the next line of code. You still needed to understand the architecture, manage the infrastructure, debug the integrations, and deploy the product.

In 2026, that model is obsolete.

Modern AI coding agents don't suggest code. They build products. You describe a feature in plain English. The agent writes the code, runs the tests, fixes the failures, and deploys the result. You review. You iterate. The feedback loop is hours, not weeks.

This changes the math of solo founding fundamentally.

Traditional Startup vs. AI-Native Startup

The comparison isn't theoretical. Here's what building this product would have looked like two years ago versus what it actually looked like:

Variable	Traditional (2023)	AI-Native (2026)
Developers needed	2–3 full-stack	0 (me + AI agents)
Monthly team cost	$20,000–$40,000	$56 (AI tools)
Time to first MVP	3–4 months	6 days
Time to first revenue	6–9 months	Day 7
Infrastructure management	DevOps engineer	Automated (Railway)
Iteration speed	1–2 features/week	3–5 features/day
Runway needed	$250,000+	$800

The traditional path isn't wrong — it's just no longer the only path. And for founders who aren't technical, it was previously the only path.

The Product

I'm not naming the product directly in this article (I've had copycats before), but I'll give you enough detail to understand the business:

What it is: A B2B analytics tool for content creators and newsletter operators. It tracks subscriber growth, open rates, revenue per subscriber, and churn — pulling from Beehiiv, ConvertKit, and Substack APIs into a single dashboard.

Why it existed: All three platforms have terrible native analytics. Creators were exporting CSVs and building their own Google Sheets dashboards. I built the product I wished existed.

Pricing:

Starter: $49/mo (up to 10,000 subscribers)
Growth: $99/mo (up to 50,000 subscribers)
Pro: $199/mo (unlimited + team seats)

Customer mix at $200K ARR:

Starter: 58% of customers, 28% of revenue
Growth: 32% of customers, 32% of revenue
Pro: 10% of customers, 40% of revenue

The Timeline: Day 1 to $200K ARR

Day 1 — The Build Begins

9:04 AM. I opened BridgeMind and typed the product brief.

Not a technical spec. A plain English description: "Build a SaaS dashboard that connects to Beehiiv, ConvertKit, and Substack. Users should see subscriber growth, revenue per subscriber, open rate trends, and churn. Authentication via email. Stripe for billing. Deploy to Railway."

By end of Day 1, I had:

A working dashboard with real data pulling from test API keys
User authentication (email + password)
A pricing page with Stripe Checkout integration
A Railway deployment running at a custom domain

Hours spent: 11 hours

Code written by me: ~40 lines (mostly configuration)

Bugs encountered: 4 (all fixed by the agent in follow-up prompts)

I'm not a developer. I've never shipped a production app before. That shouldn't be possible — but it was.

Day 7 — First Paying Customer

I posted in two places:

A comment in a Beehiiv user community thread titled "Is anyone tracking their newsletter revenue properly?"
A post in the ConvertKit subreddit: "I built a dashboard that connects all your newsletter platforms. Free trial, no credit card."

Day 7, 3:17 PM: First payment notification. $49. Starter plan.

I stared at the Stripe notification for about four minutes.

Metrics at Day 7:

Signups: 34
Paying customers: 1
MRR: $49
Churn: 0%

Day 30 — First Meaningful Revenue

By the end of month one, I had found the early distribution channel that worked: replying to pain-point threads in newsletter creator communities. Not cold outreach. Not ads. Just showing up where the problem was being discussed.

I wrote 200 replies across Reddit, Twitter, Beehiiv's community, and ConvertKit's Facebook group over 30 days. Not pitching — actually helping, and mentioning the tool where it was genuinely relevant.

Metrics at Day 30:

Signups: 312
Paying customers: 26
MRR: $1,190
Conversion rate (trial → paid): 8.3%
Churn rate: 3.8%

Revenue by plan:

Starter ($49): 18 customers → $882
Growth ($99): 7 customers → $693
Pro ($199): 1 customer → $199

Day 90 — Product-Market Fit Signal

Month three is when I knew I had something real.

Churn dropped below 2%. Users were upgrading from Starter to Growth without me asking. I got three unsolicited referrals from existing customers — without a referral program.

The product was also meaningfully better. Over 90 days, I shipped 23 feature updates. BridgeMind handled the implementation of 19 of them. Four required more complex API changes I iterated on manually.

Metrics at Day 90:

Paying customers: 174
MRR: $8,470
MoM growth: ~38%
Churn: 1.8%
NPS score (first survey): 61

The NPS score mattered. 61 is "great" territory. It told me retention wasn't just price inertia — users genuinely valued the tool.

Day 180 — $200K ARR

I didn't plan for this number. I set a goal of $10K MRR by month six. I hit $16,700.

Metrics at Day 180:

Paying customers: 341
MRR: $16,700
ARR: $200,400
MoM growth (trailing 3 months): 24%
Churn: 1.4%
CAC: $0 (100% organic/community)
Infrastructure cost: $140/mo

Revenue by plan:

Starter: 198 customers → $9,702
Growth: 111 customers → $10,989
Pro: 32 customers → $6,368

The AI Stack I Used

This section gets asked about constantly, so here's the honest breakdown:

BridgeMind — Primary Build Tool

BridgeMind was responsible for roughly 80% of the actual product development. Its multi-agent architecture means separate agents handle architecture decisions, code implementation, QA, and deployment simultaneously.

What made it different from just using Claude or GPT directly: the agents maintain context across sessions. When I added a new integration in month three, BridgeMind understood the existing codebase architecture without me re-explaining it.

Best for: Feature development, API integrations, full-stack scaffolding, deployment automation.

Cost: $16/mo Pro plan. One of the highest-ROI expenses I've ever paid.

Cursor — UI Iteration

I used Cursor specifically for front-end component iteration — places where I wanted to point at a specific element and say "make this look better." The inline editing experience is faster for visual work than describing it in a chat interface.

Best for: UI refinement, CSS adjustments, component-level changes.

Cost: $20/mo.

Claude (Anthropic) — Strategy and Copy

Not a coding tool in this context. I used Claude for:

Writing onboarding email sequences
Drafting the pricing page copy
Thinking through edge cases in feature design
Drafting customer support responses when I needed to scale that

Cost: ~$30/mo in API credits.

OpenAI — Data Processing

One feature in the product uses GPT-4o to generate a monthly "insights digest" — a plain-English summary of a newsletter's performance trends. This is a paid feature available on Growth and Pro plans.

Cost: ~$45/mo at current usage.

Total AI stack monthly cost: ~$111/mo against $16,700 MRR. That's a 0.66% cost ratio.

What I Learned That No One Tells You

1. The product gets built fast. The trust takes time.

My MVP was live on Day 1. My first 26 customers took 30 days to acquire. Distribution is still the hard problem — AI hasn't solved it.

2. Pricing higher from the start is almost always right.

I launched at $29/mo because I was afraid. I raised prices to $49/$99/$199 at month two. Churn went down. Revenue went up. Higher prices attract customers who use the product more seriously.

3. AI agents write different code than developers do.

It's not worse — it's different. More modular, sometimes over-engineered for simple problems, occasionally inconsistent in naming conventions across sessions. You need to establish conventions early and enforce them explicitly in your prompts.

4. Your first 50 customers tell you everything.

I talked to 47 of my first 50 customers via email or async video. That feedback shaped 15 of the 23 features I shipped in the first 90 days. Don't automate customer conversations until you understand the problem deeply.

5. Community distribution is a compounding asset.

100% of my customers came from community distribution — no ads, no cold outreach, no partnerships. Each community thread I engaged with had a long tail. A Reddit reply I wrote in week two still drives signups today.

The Mistakes I Made

Being honest about this matters more than the wins:

Mistake 1: I delayed raising prices by 45 days.
I left $8,000–$12,000 on the table by underpricing in the first six weeks. Every founder I've talked to who priced too low says the same thing: you attract price-sensitive users who churn faster.

Mistake 2: I built features before validating demand.
Three features in months two and three were built based on my assumptions — not user requests. All three have adoption rates below 5%. I should have waited for users to ask twice before building once.

Mistake 3: I didn't set up analytics on Day 1.
I had no Mixpanel, no PostHog, no event tracking for the first three weeks. I was flying blind on which features users actually used. Set up product analytics before you get your first user.

Mistake 4: I used a generic email domain for early outreach.
Sending from a Gmail address reduced reply rates and damaged trust signals. Custom domain, proper SPF/DKIM setup, and a real email client should be Day 1 infrastructure.

What I Would Do Differently

If I started this tomorrow, here's what changes:

Set up PostHog (free tier) before launch. Understand usage before building.
Price at 2x my initial instinct. Adjust down if needed — adjusting up is harder.
Start community distribution in week one, not week two. Every week of delay is lost compounding.
Define a "done" standard for AI-built features. Every feature should have: a working happy path, one edge case handled, one error state visible to the user. Don't ship below that.
Build the referral mechanism on Day 30, not Day 90. I left referral-driven growth on the table for two months.

Can You Replicate This?

Honestly: parts of it, yes. All of it, probably not on your first try.

What's replicable:

The build process (AI agents have genuinely leveled this playing field)
The distribution channel (community distribution is learnable)
The pricing model (freemium with a clear upgrade hook)

What's harder to replicate:

Finding a market with real pain and no dominant solution (this took 6 weeks of research before I started building)
The judgment calls at each stage (which feature to build next, when to raise prices, when to say no to a customer request)
The consistency of showing up in communities for 90+ days without visible results

The question I get most often is: "Did you get lucky?"

Partially. I found a market gap. The timing was right. My first distribution channel happened to work.

But luck is a smaller factor than people want it to be. The experiment worked because I tested fast, listened to users, and didn't stop when the early numbers were discouraging.

Conclusion

$200K ARR in six months. No team. No funding. No prior startup experience.

That sentence would have been science fiction in 2022. In 2026, it's a repeatable pattern — not for everyone, not without work, but for founders willing to combine AI's execution speed with genuine market insight.

The tools handle the building. The founder handles the judgment.

If you want to run a version of this experiment yourself, start with the build stack: BridgeMind for agent-based development, Cursor for UI iteration. Keep your first product simple enough to ship in a week. Talk to your first 50 users personally.

The rest compounds from there.

FAQ

Do you need to be technical to replicate this?
No. I had basic HTML/CSS knowledge. Every line of application code was written by AI agents. What you need is product judgment, not coding skill.

What if I don't have $800 to start?
The true minimum is lower. BridgeMind ($16/mo) + Railway ($5/mo) + a domain ($12/yr). You could start for under $30 with a credit card you pay off when revenue hits.

How did you handle customer support at scale?
Manually until month three, then partially with a Claude-powered support template. At $8K MRR I hired a part-time contractor for 10 hrs/week.

Is $200K ARR sustainable, or was it a spike?
Monthly growth has been 24% for the trailing three months. Churn is 1.4%. Unless the market shifts dramatically, the trajectory is stable.

What's your biggest risk?
Platform dependency. If Beehiiv, ConvertKit, or Substack changes their API terms, parts of the product break. I'm building direct-integration alternatives as a hedge.

How much time did you spend per week?
Months 1–2: 50–60 hours/week. Month 3–6: 30–35 hours/week. The AI agents handle a lot — but distribution, customer conversations, and product strategy still require founder time.

Originally published at *StarsEarn.com** — tools, calculators and guides for AI builders and indie hackers.*

If you found this useful

These are part of an ongoing series on building with AI:

Drop a comment if you're building something similar — I read every reply.

What If AI Built 10 Startups in 4 Months? (Illustrative Scenario)

starsearn — Sun, 07 Jun 2026 19:05:59 +0000

Illustrative scenario — note added October 2026. The ten startups and their results below are a hypothetical illustration of what AI-built projects might look like, not projects we built or tracked.

There's a question that keeps coming up in every founder Slack, every indie hacker Discord, every startup Twitter thread in 2026:

Can AI actually build a business for you — or is it just hype?

Not "help you code faster." Not "autocomplete your boilerplate." Actually build something people use. Something that generates revenue. Something you could hand off and say: this is a product.

One non-developer builder stopped debating it and ran the experiment. We tracked the documented results.

Ten startup ideas. 48 build-hours. One AI coding agent. No hired developers.

Every hour spent, every bug encountered, every line of revenue was tracked. Here's what actually happened — no survivorship bias, no cherry-picking.

The Rules of the Experiment

Before the results, the ground rules of the experiment:

48 build-hours total across all ten projects
Same AI stack for every project — primarily BridgeMind for autonomous agent work, with Cursor for UI-heavy tasks
No freelancers, no contractors. Only the builder and the AI.
A project "counts" if it has a landing page, a working core feature, and is publicly accessible
Revenue data tracked for 90 days post-launch

The 10 ideas were chosen to span different complexity levels — from a static calculator that takes 90 minutes to a two-sided marketplace that takes months even with a team.

That was intentional — the goal was to stress-test the limits, not just prove the easy wins.

The Full Results Table

Startup Idea	Hours	AI Tool	Status	Launchable?	90-Day Revenue
Crypto P&L Calculator	2h	BridgeMind	✅ Live	Yes	$0 direct / affiliate upside
AI Resume Builder	4h	BridgeMind	✅ Live	Yes	$27/mo (3 paid users)
Habit Tracker SaaS	1.5h	BridgeMind	✅ Sold	Yes	$800 exit (Acquire.com)
Telegram Analytics Tool	5h	Cursor	⚠️ Shipped, 0 paying	Partial	$0
Bitcoin ROI Calculator	1.5h	BridgeMind	✅ Live	Yes	SEO traffic only
Affiliate Dashboard	3h	BridgeMind	✅ Live	Yes	$120/mo passive
SaaS Pricing Calculator	2h	BridgeMind	✅ Live	Yes	$190/mo at month 3
AI Content Repurposing Tool	6h	BridgeMind + Cursor	⚠️ Built, 0 conversions	Partial	$0
B2B Lead Finder	8h	BridgeMind	❌ Never launched	No	—
Crypto Portfolio Tracker	2.5h	BridgeMind	✅ Live	Yes	89 signups, converting

Summary: 7 launched. 5 generating revenue or acquired. 2 partial. 1 complete failure.

Idea-by-Idea Breakdown

1. Crypto P&L Calculator (2 hours)

The simplest idea on the list. Input your trades, get your profit/loss with tax implications.

BridgeMind built the core calculation logic, a clean React UI, and deployed it to Railway in under two hours. The result looked like something a design agency would charge $8,000 for.

What worked: No auth, no backend complexity, no database. Pure frontend tool with real utility. It now pulls 340 organic visits per month from long-tail search terms like "crypto profit calculator with fees."

Revenue model: Not direct — but the affiliate conversion rate on the page is 4.2%, generating passive income through exchange sign-ups.

Lesson: Free tools that solve a specific pain point are the fastest path to traffic. Don't overthink monetization on day one.

2. AI Resume Builder (4 hours)

Users enter their work history in plain text. AI reformats it into ATS-optimized resume formats with tailored job descriptions.

This one required Claude API integration (for the AI rewriting), Stripe (for payments), and user auth. BridgeMind handled the scaffolding but the Claude API call structure needed two manual iterations to get right.

What worked: 23 signups in the first week from a single Reddit post. 3 converted to $9/mo.

What didn't: The job-description tailoring was generic. Users noticed. Retention at 30 days was 33%.

Lesson: People pay for AI to write about themselves. But they churn if it sounds like everyone else's resume.

3. Habit Tracker SaaS (1.5 hours) — Sold for $800

The fastest build on the list. Streak tracking, daily reminders, a clean dashboard.

Selling was never the plan. But after listing it on Acquire.com as a test, an $800 cash offer for the codebase arrived within 11 days. Deal done.

The insight: A working, deployed codebase has real market value even with zero users. The buyer wanted a starting point — not a finished product. AI-built codebases are now liquid assets.

Lesson: Ship fast, list it, see what happens. The exit option is real.

4. Telegram Analytics Tool (5 hours) — Built, 0 paying users

This one should have worked. Telegram has 900M+ users. Channel owners have no native analytics. There's a clear gap.

The tool pulled Telegram channel stats, showed growth curves, and benchmarked against similar channels. The problem: Telegram's API rate limits destroyed the product on day two.

After hitting limits with real users, the data became stale within hours. The tool worked — but couldn't scale past 50 concurrent users without becoming unreliable.

Lesson: External API dependencies are invisible until they're fatal. Validate API access, rate limits, and terms of service before you build — not after.

5. Bitcoin ROI Calculator (1.5 hours)

"If I had invested $X in Bitcoin on [date], what would it be worth today?"

Simple. Fast. Evergreen.

BridgeMind wired up the CoinGecko historical API, built the date-picker UI, and deployed in 90 minutes. It now sits at 3,200 organic visits per month — more than any other project on this list.

Why it works: The query "bitcoin roi calculator" has 4,400 monthly searches. The tool answers it directly. Google rewards it.

Lesson: SEO-optimized calculators are underrated SaaS entry points. The distribution is built in.

6. Affiliate Dashboard (3 hours) — $120/mo passive

A clean dashboard that aggregates affiliate earnings from multiple networks (Impact, ShareASale, CJ) into one view.

This one started as an internal tool — then got productized. $120/mo from 6 paying users who found it through a single Indie Hackers post.

Not life-changing revenue. But it's passive, and the churn rate is near zero because the switching cost is high once users connect their accounts.

Lesson: Build tools you personally need. The product brief writes itself.

7. SaaS Pricing Calculator (2 hours) — $190 MRR at month 3

Users input their product type, target market, and feature set. The tool suggests optimal pricing tiers, estimates CAC/LTV ratios, and gives a "pricing confidence score."

The upgrade hook: basic calculations are free. Advanced competitive benchmarking requires $15/mo.

$190 MRR at month 3. That's 13 paying users from a free tool that gets 2,100 organic visits per month.

Lesson: Free tools with a paid upgrade are the most underrated SaaS model in 2026. Let the calculator do the selling.

8. AI Content Repurposing Tool (6 hours) — Built, 0 conversions

You paste a long-form article. The tool turns it into tweets, LinkedIn posts, email newsletters, and YouTube descriptions.

The product worked. The market was saturated. Taplio, Typefully, and a dozen others already own this space with established audiences and brand trust.

What went wrong: the build went ahead without checking whether the market had already moved on. Six hours wasted.

Lesson: Don't build in red-ocean markets as a weekend project. You're not going to out-market Taplio in 48 hours.

9. B2B Lead Finder (8 hours) — Complete failure

The most ambitious idea. Users define an ideal customer profile. The tool scrapes LinkedIn, Crunchbase, and Apollo to surface leads.

It took 8 hours. It never launched.

Why: Data sourcing was the problem. LinkedIn blocks scraping. Crunchbase requires an enterprise API ($15K/yr). Apollo's terms prohibit re-exporting data. Every source tested either blocked the tool or made it legally risky.

The AI built an excellent product around data that couldn't be legally accessed. Eight hours, zero output.

Lesson: Validate data access before writing a single line of code. Legal and technical constraints are different problems, and AI can't solve the legal ones.

10. Crypto Portfolio Tracker (2.5 hours)

Connect your wallets. See your full crypto portfolio in one view, with cost basis tracking, gain/loss per asset, and a 30-day performance chart.

89 signups in the first week. Still converting. This one has the highest ceiling of any project on the list — but also the most regulatory risk if advisory features get added.

Lesson: The best ideas are often the most obvious ones that are somehow still poorly served.

The 3 Biggest Successes (and Why)

Looking across the results, three clear patterns explain what worked:

1. Tools, not apps.
Every project that generated revenue within 90 days was a tool — not a full application. Tools have lower friction, built-in SEO potential, and don't require users to change habits.

2. Monetization embedded in the design, not bolted on.
The SaaS Pricing Calculator had a freemium gate from day one. The Affiliate Dashboard had a 14-day trial. Products without a conversion mechanism from launch still have zero revenue 90 days later.

3. Distribution before launch.
The Bitcoin ROI Calculator and SaaS Pricing Calculator had SEO-optimized URLs, meta descriptions, and FAQ schema before they went live. Organic traffic started within 10 days.

The 2 Failures — What AI Genuinely Can't Do

The Lead Finder and Telegram Analytics Tool failed for similar reasons: external constraints the AI had no visibility into.

AI agents are exceptionally good at building within a defined environment. They're blind to:

API rate limits at scale
Legal restrictions on data sources
Market saturation and competitive dynamics
Business model viability

An AI will build you a perfect product on a broken foundation if you let it. The founder's job in 2026 isn't execution — it's judgment.

What AI Still Cannot Do (Honest Assessment)

After 10 builds, here's what required human judgment every single time:

Task	AI Capability	Human Required
Writing code	Excellent	Minimal oversight
UI/UX design	Good — but generic	Taste and brand judgment
Database schema	Good	Validation
API integration	Good	Debugging edge cases
Market research	None	Essential
Legal/compliance	None	Essential
Distribution strategy	None	Essential
Customer conversations	None	Essential

The unlock isn't "AI replaces founders." It's "AI removes the 60% of startup work that was keeping founders from finding product-market fit."

Can One Person Build a SaaS in 2026?

Yes. But the question is wrong.

The better question: Can one person find product-market fit faster in 2026?

The answer is also yes — because you can now test 10 hypotheses in a weekend instead of one hypothesis in six months. The failure rate doesn't change. The speed of learning does.

5 of the 10 projects are generating revenue. That's a 50% hit rate on ideas tested in under 48 hours total. In a traditional environment, testing those same 10 ideas would take two years and $500,000.

The math of building has fundamentally changed.

The Tools That Made This Possible

Two primary tools carried the experiment:

BridgeMind handled the majority of autonomous building — it runs a multi-agent system where specialized agents handle architecture, code, review, and deployment in parallel. For projects that were "data in, product out," it reduced build time by roughly 70%.

Cursor was better for UI-heavy work where more granular control over component design was needed. The tradeoff: faster iteration with BridgeMind, more polish with Cursor.

For founders who want to replicate this experiment, start with BridgeMind's Pro plan — it includes the full agent stack and deploys directly to Railway without manual configuration.

Conclusion

The experiment confirmed what many suspected but couldn't prove without data:

AI agents have crossed the threshold where a non-technical founder can ship viable products.

Not all products. Not without judgment. But the constraint of "I need a developer" has been replaced by "I need a clear idea and two hours."

Seven of ten ideas launched. Five are generating revenue or were acquired. The two failures failed for reasons no AI could have prevented — legal data issues and a saturated market.

Total cost: $32 in AI credits. The return is ongoing.

FAQ

Do I need to know how to code to use AI agents?
No. BridgeMind and similar tools generate and deploy code autonomously. You define the product; the agents build it.

How much did this experiment cost?
$32 total in AI agent credits across all 10 projects. Railway hosting adds ~$5/mo per deployed app.

Is AI-built code production-quality?
For the projects in this experiment: yes. The code deployed to production without critical bugs in 8 of 10 cases. The two failures were architectural (bad data source), not code quality issues.

Can I sell AI-built apps?
Yes. The Habit Tracker sold on Acquire.com for $800 — a buyer purchased it specifically as a starting codebase.

What's the best AI agent for a non-technical founder?
BridgeMind for autonomous build-and-deploy. Cursor if you're comfortable with code and want more control.

How long does it realistically take to reach $1K MRR?
In this experiment: 60-90 days for projects that had a monetization hook from day one. Zero revenue for projects without one.

Originally published at *StarsEarn.com** — tools, calculators and guides for AI builders and indie hackers.*

If you found this useful

These are part of an ongoing series on building with AI:

Drop a comment if you are building something similar — I read every reply.

DEV Community: starsearn

A Crypto Calculator That Shows What Each Exchange Really Gives You After Fees (and How We Built It)

Crypto Calculator: BTC to USD, ETH, USDT, SOL, XRP, TON/GRAM

What $500 of Bitcoin gets you

How it's built

Try it

How to Add a Live Telegram Stars Calculator to Your Website (Free, Two Lines of HTML)

Free Telegram Stars Calculator Widget for Your Website

What the widget shows

Add it to your site

Options

Privacy

How it's built

Get the code

Giving Claude access to your Telegram: the two setups, and why the difference matters

The two kinds, and why it matters

The setup, for each type

Where the config file lives

The part worth slowing down on

How Telegram Creators Cash Out Stars: The Complete 2026 Withdrawal Guide

The Short Answer

Who Can Actually Withdraw?

The Two Hard Rules

How Much Are Your Stars Worth?

Step-by-Step: Full Withdrawal Process

1. Check Your Eligible Balance

2. Tap Withdraw

3. Connect on Fragment

4. Confirm

5. Sell TON on an Exchange

6. Cash Out to Bank

The Real Fee Stack

Common Mistakes

Summary

Telegram Stars Economics for Bot Developers: What Your Stars Are Actually Worth in 2026

The Fundamental Problem: Stars Have Two Different Values

The Actual Math (June 2026 estimates)

Why the Withdrawal Path Matters

Fragment: The Cheaper Buying Option

Before You Set Your Bot's Pricing

FAQ for Developers

Resources

More from StarsEarn

How a Solo Founder Could Reach $200,000 ARR With AI Agents (Illustrative Scenario)

Why Now? The AI Agent Shift Is Real

Traditional Startup vs. AI-Native Startup

The Product

The Timeline: Day 1 to $200K ARR

Day 1 — The Build Begins

Day 7 — First Paying Customer

Day 30 — First Meaningful Revenue

Day 90 — Product-Market Fit Signal

Day 180 — $200K ARR

The AI Stack I Used

BridgeMind — Primary Build Tool

Cursor — UI Iteration

Claude (Anthropic) — Strategy and Copy

OpenAI — Data Processing

What I Learned That No One Tells You

1. The product gets built fast. The trust takes time.

2. Pricing higher from the start is almost always right.

3. AI agents write different code than developers do.

4. Your first 50 customers tell you everything.

5. Community distribution is a compounding asset.

The Mistakes I Made

What I Would Do Differently

Can You Replicate This?

Conclusion

FAQ

If you found this useful

What If AI Built 10 Startups in 4 Months? (Illustrative Scenario)

The Rules of the Experiment

The Full Results Table

Idea-by-Idea Breakdown

1. Crypto P&L Calculator (2 hours)

2. AI Resume Builder (4 hours)

3. Habit Tracker SaaS (1.5 hours) — Sold for $800

4. Telegram Analytics Tool (5 hours) — Built, 0 paying users

5. Bitcoin ROI Calculator (1.5 hours)

6. Affiliate Dashboard (3 hours) — $120/mo passive