DEV Community: holdi

Build a $0-Cost Automated Store with a Telegram Bot: A Practical Guide

holdi — Fri, 30 Oct 2026 12:01:20 +0000

Selling digital products doesn't require Shopify, WooCommerce, or Stripe subscriptions. You can run a functional e-commerce operation entirely from your laptop using Telegram and your existing web hosting.

This guide focuses on a specific, high-volume model: selling packs of pre-made credentials (e.g., social media accounts) or simple digital assets. We will build this using a Telegram Bot, a Node.js backend, and a shared server.

The Architecture

We will implement a flow that requires zero maintenance from you after deployment:

User Interaction: A Telegram bot receives a message with the product code (e.g., /buy_1).
Payment: The bot returns a crypto wallet address for the user to send payment.
Processing: The user sends the payment receipt.
Delivery: The bot verifies the transaction on-chain, then automatically sends the product file to the user.

This avoids the complexity of Stripe and integrates perfectly with crypto payments.

Step 1: The Development Environment

Create a new project folder and initialize a Node.js application.

mkdir telegram-store
cd telegram-store
npm init -y
npm install express axios telegraf dotenv

express: To run a simple web server.
axios: To make HTTP requests to block explorers.
telegraf: The robust framework for handling Telegram bot logic.
dotenv: To manage your API keys securely.

Create a .env file in the root directory:

BOT_TOKEN=YOUR_TELEGRAM_BOT_TOKEN
PORT=3000
COIN_SYMBOL=USDT

Step 2: The Bot Logic

Create a file named server.js. This script handles the bot logic.

We need a simple inventory system. For this example, we will use an array of objects representing available products.

const { Telegraf } = require('telegraf');
const express = require('express');
require('dotenv').config();

const bot = new Telegraf(process.env.BOT_TOKEN);
const app = express();
app.use(express.json());

// Inventory: ID, Price in Crypto, File URL (or path)
const products = [
  { id: '1', name: 'Instagram Pack', price: 10, link: 'https://example.com/file.zip' },
  { id: '2', name: 'Twitter Pack', price: 15, link: 'https://example.com/file.zip' }
];

// User state management
// Keys are user IDs, values are objects containing current state and cart
const sessions = {};

bot.start((ctx) => ctx.reply('Welcome! Send /buy_1 to purchase the first pack.'));

// Command to buy
bot.command('buy_1', (ctx) => {
  const userId = ctx.from.id;
  sessions[userId] = { step: 'awaiting_payment', productId: '1' };
  ctx.reply(`Select payment method: Send a screenshot of USDT sent to: \`0x...\``);
  ctx.replyWithMarkdown(`\`0x123...abc\` (10 ${process.env.COIN_SYMBOL})`);
});

// Handle incoming text messages (payment receipts)
bot.on('text', async (ctx) => {
  const userId = ctx.from.id;
  const userSession = sessions[userId];

  if (!userSession) return; // Ignore messages from users not in the store flow

  if (userSession.step === 'awaiting_payment') {
    // 1. Verify Payment (Simplified Logic)
    // In a real scenario, you would verify the hash on a blockchain explorer.
    // For this demo, we simulate the delay.

    ctx.reply('Processing payment... please wait.');

    // Simulate async processing
    setTimeout(async () => {
      try {
        // 2. Send Product
        const product = products.find(p => p.id === userSession.productId);
        await ctx.reply('Payment Verified!');
        await ctx.replyWithPhoto({ source: 'path/to/proof.jpg' }); // Optional: Proof of purchase
        await ctx.replyWithDocument({ source: product.link });
        delete sessions[userId]; // End session
      } catch (error) {
        ctx.reply('Error delivering the file.');
        delete sessions[userId];
      }
    }, 3000);
  }
});

// Start the bot
bot.startPolling();

// Start the Express server
app.listen(process.env.PORT, () => {
  console.log(`Server running on port ${process.env.PORT}`);
});

Step 3: Hosting for $0

Do not pay for VPS providers like DigitalOcean or AWS. You need a server with a public IP address.

Get a Free VPS: Sign up for Render.com (supports Node.js), Railway.app, or Fly.io. These platforms often offer a free tier that lasts 6 months.
Deploy: Push your code to GitHub and connect the repository to your hosting provider. Render will automatically detect package.json, install dependencies, and run node server.js.

Step 4: The "Glue" (Optional but Recommended)

Running a bot solely on a single server with one user connection can sometimes result in timeouts. To make it robust, use ngrok to tunnel your local port to the internet, or set up a proper server configuration.

If you are using Render, simply ensuring your code listens on process.env.PORT is usually sufficient for a low-traffic store.

Managing Risks

This model is high-risk regarding ToS (Terms of Service) and legal compliance.

File Hosting: You cannot use your free hosting account's storage for sensitive files. Use a dedicated file storage service like Dropbox, Google Drive (with sharing links), or a cheap CDN. If your free hosting quota is reached, the bot stops working.
Bans: Telegram will ban bots that do not respond to users. Ensure your code includes error handling so the bot remains online even if one user's payment fails.

Conclusion

You now have the code and the workflow to automate a digital store. The barrier to entry is the code, not the infrastructure. By using Telegram's native API, you reduce friction for the buyer and eliminate transaction fees.

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot

Why Creators Fail at Selling Prompts (and How to Fix It)

holdi — Thu, 29 Oct 2026 12:10:41 +0000

You’ve spent weeks refining a Midjourney style, engineering the perfect Stable Diffusion workflow, or writing the exact structure of a system prompt that outperforms the competition.

You polish it, package it, and list it on Gumroad or your personal site. You set the price, maybe $10, maybe $20. Then? Radio silence.

It’s frustrating. You aren’t selling prompts because you aren't marketing them as tools.

Here is the brutal reality: A prompt is not a product.

1. You are selling a bad copy-paste, not a result

Most creators treat prompts like magic spells. They say, "Buy this prompt and make magic happen." This is a lie.

When a buyer copies your text into ChatGPT, they still have to do the work. They still have to tweak the temperature, adjust the context window, and iterate until it works. You are selling them a rough draft, not a finished deliverable.

If the buyer isn't a prompt engineer, they will open it, see a wall of text, and close it. They aren't failing to use it; they are failing to see the value immediately.

The Fix: Shift the angle. Don't sell "The Prompt." Sell "The Result." Create a digital pack that includes the prompt plus a short guide on how to prompt engineer it, or include a few "fallback" variations so the user doesn't have to guess. Give them a tool, not just a text string.

2. The "Solution to a Problem You Don't Have" Trap

This is the most common mistake. Creators sell prompts they love, not prompts people need.

You might have a prompt that generates hyper-realistic cyberpunk portraits. That's cool. But the average person searching for prompts wants to write emails, generate code snippets, or plan their marketing calendar. They don't care about "cyberpunk portraits" unless they are a cyberpunk artist.

You are marketing to yourself, not your audience. If you don't understand the specific pain point (e.g., "I hate writing cold outreach emails"), your prompt will flop.

The Fix: Go to Twitter, Reddit, or Upwork. Look at the burning questions people are asking AI. Build your prompt to answer that specific question instantly. If someone asks, "How do I write a persuasive landing page?" and you sell them a generic "creative writing" prompt, you lose. You need to solve a specific, immediate problem.

3. Lazy Packaging and Zero Trust

Look at a standard prompt listing: A blurry preview image and a paragraph of text. That is it.

This signals low value. Why would someone pay $15 for a few lines of text? In the digital world, trust is visual and structural. If you don't show how the prompt works or why it is better than the free one on GitHub, you will struggle to convert.

The Fix: Over-deliver on the delivery. If you sell a "Midjourney Architectural Style" pack, give them:

The actual prompt text.
A 30-second video showing the output.
A breakdown of the parameters (e.g., "We used --stylize 750 here").
A "Copy-Paste" button.

Make the buyer feel like they are buying a premium course, not a text file.

4. Ignoring the Workflow

Selling a single prompt is a transaction. Selling a workflow is a subscription.

The prompt is just one step in the process. A "Code Refactor" prompt might need to be fed into a "Code Explainer" prompt, followed by a "Security Checker" prompt. If you sell them the first piece, they will need the rest. This creates a natural pathway for upselling.

The Fix: Bundle related prompts into a "Suite" or "Workflow." Position your product as a complete solution to a complex task rather than a single line of code.

5. Putting all your eggs in one basket

Posting once on X and hoping for the best is not a marketing strategy. If you are a solo creator, you are competing with billion-dollar companies that have armies of designers and copywriters. They don't need to sell prompts; they use them for free.

You need to show up where your customers hang out.

The Fix: Build an asset library. Take your best 10 prompts, turn them into a Notion template or a PDF checklist. Post this content for free on Twitter or LinkedIn. When people interact with the free content, they become familiar with your style. Once they trust you, they are much more likely to pay for the premium pack.

Summary

Creators fail because they view prompts as passive inventory. They don't.

If you want to sell prompts successfully, you must act like a consultant, not a reseller. You must understand the user's problem, package the prompt in a way that reduces friction, and demonstrate the value through delivery.

Stop selling text. Start selling results.

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot

How to Deliver Digital Downloads Automatically with No Backend

holdi — Mon, 26 Oct 2026 12:08:41 +0000

You do not need a server to sell digital files. You do not need a database to track downloads. You do not need a monthly bill for Stripe or PayPal processing.

As a developer or freelancer, the most frustrating part of selling digital assets isn't writing the code. It is the operations overhead: uploading files to a cloud bucket, managing expiration links, and dealing with customers who say "the download failed."

You can build a storefront that handles delivery end-to-end on the frontend. This is practical, secure enough for most use cases, and removes your reliance on backend infrastructure.

Here is the practical guide to doing it.

1. The Client-Side Payment Strategy

You need a payment processor that runs entirely in the browser. Stripe Checkout is the standard here. It is a hosted page, which is good for PCI compliance, but it needs to handle the return logic.

When the user completes payment, Stripe sends a postback (webhook) or you can handle the response via your frontend code if you are using Elements.

For this architecture, we use Stripe Elements with the Payment Intents API. The frontend initiates the payment. Once Stripe confirms success, we swap the UI from a "Pay" button to a "Download" state without ever talking to your server.

2. The File Hosting Setup

You need a place to store the files. Do not use your main website’s public folder or a local machine. You need a dedicated CDN or object storage.

For simplicity, use Cloudflare R2 (S3 compatible) or Netlify Drop. If you are using Next.js, you can place your assets in the public folder, but for a scalable "store" feel, use a static storage provider. Upload your file (e.g., asset.zip) and copy the direct URL.

Example folder structure:

/my-store
  /assets
    /premium-guide.pdf
    /source-code.zip

3. The Architecture: Client-Side Flow

The logic is simple:

User fills credit card.
You verify payment on the client (or backend proxy).
On success: You show a download link.

Here is a practical React example using Stripe Elements.

Step A: Initialize Payment
Create a function that calls Stripe to create a PaymentIntent. This ensures the card is valid.

// Create a PaymentIntent on your backend to check if they paid.
// If this were zero-backend, you might simply trust the client for demo purposes,
// but for a real store, always validate with your backend.
const { clientSecret } = await fetch('/api/create-payment-intent', {
  method: 'POST',
  body: JSON.stringify({ amount: 2000, currency: 'usd', itemId: 'premium-guide' }),
}).then(r => r.json());

// Confirm the payment
const { error, paymentIntent } = await stripe.confirmCardPayment(clientSecret, {
  payment_method: { card: cardElement },
});

Step B: Handle Success & Deliver
If error is null, the payment went through. Now, you must deliver the file. Since we have no backend, we retrieve the file URL from our storage directly.

if (!error) {
  // The payment succeeded.
  const fileUrl = "https://your-cdn.com/assets/premium-guide.pdf";

  // You can trigger the download immediately
  window.location.href = fileUrl;

  // Or show a nice UI
  setDownloadState({ 
    status: 'paid', 
    downloadUrl: fileUrl,
    fileName: 'Premium_Guide.pdf'
  });
}

4. Security: How to Prevent Free Rides

The biggest risk of "no backend" is that a user pays, gets the link, and then shares that link with a friend. Without a server to check "Has this user ID paid?", you have no defense against link sharing.

To solve this, you use Signed URLs.

You cannot generate a valid signed URL on the frontend (this would require exposing your secret key). Instead, you send a request to a tiny "middleware" function on your backend that does two things:

Checks if the user has a valid session or payment record.
Generates a temporary signed URL for the file (valid for 15 minutes).
Returns that signed URL to the frontend.

The frontend then hides the raw CDN link and shows the user only the signed link provided by your tiny middleware.

Example Middleware (Node/Express)

app.get('/api/get-file/:id', (req, res) => {
  // 1. Validate user session or check DB for payment status
  const userPaid = checkUserPaymentStatus(req.session.userId);

  if (!userPaid) {
    return res.status(403).send('Access Denied');
  }

  // 2. Get the signed URL from your storage provider
  // R2, CloudFront, or AWS S3 presigned URLs are standard here
  const signedUrl = s3Client.getSignedUrl('GetObject', {
    Bucket: 'my-assets',
    Key: `assets/${req.params.id}`,
    Expires: 900 // 15 minutes
  });

  res.json({ url: signedUrl });
});

This approach gives you the security of a backend without running a complex application server for file serving.

5. Managing Digital Goods at Scale

If you are selling 1,000s of items, you need an automated way to handle file uploads. You can write a script that hits the storage API to upload files, and then simply save the metadata (filename, price, file URL) in a simple JSON file or a cheap database like Supabase.

When a customer buys, your middleware just reads that JSON file to verify ownership.

Summary of the Stack

Payments: Stripe Elements + Payment Intents
Hosting: Cloudflare R2 / Netlify Drop (Static)
Middleware: A single Express endpoint for Signed URLs
Delivery: window.location.href on success

This removes the friction of deployment and allows you to focus on the product. You don't need to worry about hosting costs or downtime affecting your customers.

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot

Why Creators Fail at Selling Prompts (and How to Fix It)

holdi — Sun, 25 Oct 2026 10:34:53 +0000

The Market Reality
Every week, dozens of AI engineers and prompt engineers launch digital packs on Gumroad, PromptBase, or X (Twitter). Most of them eventually shut down or move to a smaller platform. Why? Because they are treating prompts like commodities—digital assets that should sell on volume alone.

The harsh truth is: Prompts are tools, not products. A generic prompt library is not a business. It’s a digital hoard.

The "Tool" vs. "Product" Distinction
A tool solves a specific, immediate problem. A product has a brand, a promise, and an emotional hook.

If you are selling a pack of "Midjourney Prompts for Landscapes," you are competing on price. You are asking users to scroll through a spreadsheet of text. You are forcing them to do the work of testing and filtering to find something that works.

The best prompts solve the hardest part of the problem for the user. They handle the context, the logic, and the iterative refinement. If your prompt pack saves a freelancer 20 hours of research and trial and error, it has value. If it just gives them 100 slightly different phrases, it has zero value.

Stop "Fluffing" the Capabilities
The number one reason creators fail is exaggeration.

Listing your prompt pack on a marketplace is easy. Copy-pasting text into a description is easy. But if you promise a prompt will generate a photorealistic movie scene in 15 seconds, you are setting the user up for a 1-star review.

Real-world testing reveals limitations. A prompt might work perfectly for photorealism but fail at hand anatomy. It might be great for writing emails but terrible at coding. Be specific. Instead of "The Best Prompt for Coding," say "A Python debugging agent that handles complex async logic." Being honest about the prompt's specific niche builds trust. Trust is the only thing that converts a browser into a buyer.

The "Magic Box" Trap
Don't hide the prompt. Don't gatekeep it behind a paywall that looks like a secret handshake.

If the user cannot see the exact wording before they pay, they have to guess. They have to assume the prompt will work. This is a high-friction barrier to sale.

To fix this, offer a "Lite" version for free. Show the user exactly what they are getting. If the prompt is just a block of text, let them read the text. If the prompt is a complex multi-step system, explain the system in the description. When a user can clearly visualize the output before they pay, hesitation vanishes.

Documentation is Non-Negotiable
You are selling a digital object. If you only provide a .txt file, you are selling a headache.

Nobody wants to figure out the context window limits, the negative prompts, or the version compatibility of your asset. If your prompt requires a specific API key or a proprietary plugin to run, you must provide a clear instruction manual.

Practical example: When I sell prompt packs, I include a JSON configuration file. I explain exactly how to load it into the frontend. I explain the token count. I explain the temperature settings required to get the specific vibe I’m going for. When the user opens the file and knows exactly what to do immediately, the perceived value jumps from "free text" to "pro software configuration."

Conclusion
Selling prompts isn't about generating text; it's about solving workflow inefficiencies. Stop selling libraries of keywords and start selling solutions that save time and reduce friction.

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot

A Beginner's Honest Guide to Selling on the Internet in 2026: Realism Over Hype

holdi — Sat, 24 Oct 2026 10:10:40 +0000

If you are a developer or freelancer looking to make money online in 2026, stop scrolling. You do not need another "overnight million-dollar" course. You need a strategy.

Selling on the internet has shifted from "build a brand" to "build a system." The days of needing a perfect landing page with 50 glowing testimonials are over. Today, the best approach is privacy-focused, permission-based, and frictionless.

Here is the practical reality of how to start selling digital products or services right now.

The New Sandbox: Privacy is Your Currency

In 2026, people are incredibly wary of data collection. If your sales process asks for a phone number, a physical address, or forces them to create an account just to buy a $5 product, you will lose the sale.

The most effective method right now is Telegram automation.

Why? It is the only mainstream platform that combines the privacy of a direct message app with the reach of a social network. You don't need to set up a complex web server or pay for Shopify. You can build a bot that delivers files directly to the user’s chat.

Choose Your Weapon: Digital Products vs. Services

Don't try to be Amazon. Be a specialist.

1. Digital Products (Low Friction)

If you code, you have products. Nobody needs a $2.99 "Landing Page Template" unless it solves a specific problem.

Real Example: A senior frontend developer creates a "UI Kit" for Tailwind CSS. Instead of trying to sell it on a website, they automate the process.
The Workflow: User sends a command (e.g., /buy-ui-kit) to the bot. The bot asks for payment, verifies it on-chain (USDT/USDC), and instantly sends a ZIP file with the assets.
Value: The user gets the file in 5 seconds. You get paid via stablecoin.

2. High-Ticket Services (High Trust)

If you offer freelance services (SEO, copywriting, coding), you need a different approach. Stop chasing clients on Upwork. The fees are too high, and the competition is AI-saturated.

Real Example: A developer runs a Telegram channel sharing snippets of code or tech insights. They put a pinned post linking to a private "Freelancer Channel."
The Workflow: Clients DM you there. Because the DM is private, you can chat 1-on-1. You quote a price, get a deposit, and deliver the work. No bidding wars.

The Technical Reality: How It Works

You do not need to be a DevOps engineer to run this. You just need two things:

A Payment Method: Crypto is the only way to automate sales without a banking license. USDT (Tether) is the standard. It is instant, global, and easy to automate.
A Bot: Services like Combot or Poodll allow you to create a Telegram bot with built-in payment processing and file delivery capabilities.

You do not code the payment logic yourself unless you want to. Use no-code tools to handle the "logic" (verifying a transaction ID and sending a file).

The Marketing Strategy: "Share to Earn"

Stop running ads. In 2026, ads are noisy and expensive. The best way to sell is by being useful.

The "Sample" Strategy: If you sell a coding script, post the code on GitHub or a dev forum. Include a comment that the full source code with documentation is available via a Telegram bot.
The "Utility" Strategy: If you sell SEO services, post a thread analyzing a competitor’s website. Then, offer a free audit via a bot. Upsell the full report to the users who engage.

This generates leads organically. You aren't selling; you are providing value first.

Avoid These Common Pitfalls

Zero Spam: Never message random people. This is how you get banned. Only sell through channels you own or through the bot's direct menu.
Don't "Gatekeep" Everything: If you are selling a $20 pack, give away one tip for free. If the value of the free tip exceeds the price of the paid pack, people will buy.
Overcomplicate the Delivery: If the download link takes three clicks to work, you have failed. Use file compression or cloud storage to make the download a one-click action.

The Bottom Line

Selling on the internet in 2026 is about convenience. If you can make it easier for someone to buy your product than it is for them to leave and go somewhere else, you will win.

Don't focus on "scaling" to a million dollars. Focus on getting one hundred users to trust you with their credit card (or crypto wallet).

Start small. Automate the delivery. Ship a product. The world needs more practical utility, not more hype.

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot

Building a $0-Cost Automated Telegram Store for Digital Goods

holdi — Mon, 19 Oct 2026 11:56:05 +0000

Running an automated store isn't just about having a website. It’s about removing friction. If you sell digital packs, code snippets, or APIs, your customer should receive the download link instantly—without asking a human to email it to them.

You don't need a Stripe account, a Shopify theme, or a backend server with Docker containers. You can build a functioning automated shop using a free tier cloud server (like Render or Railway) and a Telegram bot.

Here is the practical workflow to build a store that costs roughly $5/month in hosting.

1. The Architecture: No Payment Gateway Required

Since this is a "free" project, we must avoid standard payment gateways (Stripe/PayPal). Instead, we will use a deposit model.

How it works: The user buys "Credits" via a peer-to-peer method (like crypto or local transfer).
The Flow:
1. User finds a product in your Telegram bot.
2. User pays you (e.g., via USDT TRC20).
3. User sends the transaction hash to the bot.
4. Your backend checks the blockchain.
5. If found: Bot unlocks the file/link.
6. If not found: Bot asks for payment.

This removes 100% of chargeback risk and platform fees, keeping your margins high.

2. Set Up the Telegram Bot

You don't need the python-telegram-bot library for this specific implementation. For a lean, $0-cost solution, use the official Telegram Bot API directly via cURL.

Create your bot via the BotFather and get your TOKEN.

3. The Backend: Using a Free Platform

Don't host this on your laptop. Use a free tier from Render.com or Railway.app. These support Node.js and Python.

We will use Express.js (Node) for the server and Binance API (or TRC20 network API) to verify payments.

The Code: Payment Verification & File Delivery

Here is a minimal example using Express. When a user types /buy pack1, the bot requests a payment address. When the user sends the transaction ID, this script checks the blockchain and delivers the link.

const express = require('express');
const axios = require('axios');
const app = express();
app.use(express.json());

// 1. CONFIGURATION
const BOT_TOKEN = 'YOUR_BOT_TOKEN';
const API_URL = `https://api.telegram.org/bot${BOT_TOKEN}`;
const MY_WALLET_ADDRESS = 'YOUR_TRC20_ADDRESS';

// 2. DATA STORE (In a real app, use a DB like MongoDB or Supabase)
const products = {
  'premium_api': { price: 10, title: 'Premium API Pack', link: 'http://mysite.com/file.zip' },
  'source_code': { price: 25, title: 'Source Code Bundle', link: 'http://mysite.com/source.zip' }
};

let pendingPayments = {}; // Store pending transactions

// 3. ROUTES
app.post('/webhook', async (req, res) => {
  const message = req.body.message;
  if (!message) return res.send('');

  const chatId = message.chat.id;
  const text = message.text;

  // Handle Product Request
  if (text === '/start') {
    await sendMessage(chatId, "Welcome. Use /buy <code>premium_api</code> or /buy <code>source_code</code>");
  }

  if (text.startsWith('/buy ')) {
    const key = text.split(' ')[1];
    const product = products[key];

    if (product) {
      await sendMessage(chatId, `Buying ${product.title} costs $${product.price}. Send me a USDT (TRC20) payment for this amount to my wallet: ${MY_WALLET_ADDRESS}`);
      pendingPayments[chatId] = { key: key, price: product.price };
    }
  }

  // Handle Transaction Hash
  if (pendingPayments[chatId]) {
    const txHash = text;
    // Check Transaction on Binance API
    const status = await checkTransaction(txHash, pendingPayments[chatId].price);

    if (status) {
      // DELIVER PRODUCT
      const product = products[pendingPayments[chatId].key];
      await sendMessage(chatId, `✅ Payment Verified! Here is your download: ${product.link}`);
      delete pendingPayments[chatId];
    } else {
      await sendMessage(chatId, "❌ Payment not found or amount incorrect. Please try again.");
    }
  }

  return res.send('ok');
});

// HELPER FUNCTIONS
async function sendMessage(chatId, text) {
  await axios.post(`${API_URL}/sendMessage`, {
    chat_id: chatId,
    text: text,
    parse_mode: 'HTML'
  });
}

async function checkTransaction(hash, amount) {
  // Example: Fetch transaction details from Binance API or BscScan
  // Note: You need to implement the actual API call to verify the USDT amount
  // This is a placeholder for the logic
  return true; 
}

app.listen(process.env.PORT || 3000);

4. The "Zero-Cost" Infrastructure

To keep this running at $0 cost, you cannot use a complex database.

Database: Use Supabase (free tier) or FireStore. Alternatively, for a very small scale, stick to the pendingPayments object in memory (works as long as the server doesn't restart).
File Hosting: Use Google Drive or Dropbox public folders. Do not host the files on your backend server unless they are tiny.
SSL: Render and Railway automatically handle HTTPS certificates for your webhook URL.

5. Verification Logic (The Tricky Part)

To make this work, you must write a script that checks the blockchain.

For USDT TRC20: Use the Binance API or a public TRC20 explorer API.
For BSC/ETH: Use BscScan or Etherscan.

Your checkTransaction function should look like this in practice:

// Simplified logic to verify TRC20 transaction
async function checkTransaction(txHash, expectedAmount) {
  try {
    // Example using a public RPC node or API
    const response = await axios.get(`https://api.bscscan.com/api?module=transaction&action=gettxinfo&txhash=${txHash}&apikey=YOUR_API_KEY`);

    if (response.data.status === "1" && parseFloat(response.data.result.amount) >= expectedAmount) {
      return true;
    }
  } catch (e) {
    console.error(e);
  }
  return false;
}

6. Deploying

Create a repository on GitHub.
Push the code.
Connect your repository to Render.com (or Railway).
Render will give you a URL (e.g., https://my-bot.onrender.com).
Go to BotFather on Telegram and set your webhook to:

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot

The 3 Easiest Digital Products to Create and Sell This Month

holdi — Fri, 16 Oct 2026 10:32:58 +0000

If you are reading this, you are likely a developer or a freelancer. You understand how to build software, you understand the value of a clean UI, or you know how to turn a chaotic process into a repeatable workflow.

But there is a gap between being good at a task and selling the solution for that task. Many developers spend years learning frameworks and then struggle to find clients. The reality is, you don't need to build a SaaS to make money. You don't need to raise funding. You don't need to write complex code.

You just need to package up the boring, repetitive parts of your work into a file that someone else can buy.

Here are three digital products that require almost zero coding overhead and can be sold immediately.

1. Code Snippets & "Helper" Scripts

If you write code, you definitely reuse small chunks of logic. Whether it is a regex to clean user input, a curl command to hit a specific API endpoint, or a Python script to format a messy CSV, someone else has probably searched for this exact thing and found nothing usable.

Instead of posting it on Stack Overflow (where it gets buried), package it as a reusable script.

The Product

A single script file (e.g., clean-data.py) or a collection of snippets. These should be practical, tested, and documented. You can sell them as a "Markdown cheatsheet" with copy-paste code blocks or as raw source files.

How to Build It

Identify a boring task you do weekly.
Write a script that automates it.
Add comments explaining exactly how to run it.
Package it into a ZIP file.

Why It Sells

Developers are tired of Googling. They want a file they can download, chmod +x, and run. If you solve a small API integration headache or a data cleanup problem, the value is immediate.

2. Automate-to-Image Prompts (for UI Designers)

If you are a UI designer or a frontend dev, you know the struggle of finding the perfect texture, gradient, or 3D asset without spending hours on Shutterstock or paying for a premium tool.

You can sell your ability to generate these visuals.

The Product

A collection of raw text prompts for tools like Midjourney, DALL-E, or Stable Diffusion. These prompts should be tailored for specific UI needs—glassmorphism backgrounds, abstract tech textures, or vector icons.

How to Build It

Open a generative AI tool.
Generate 20 high-quality images.
Reverse-engineer the prompts. Copy the text that generated the best results.
Format them into a clean Markdown file or a Notion page.
Add usage instructions (e.g., "Use --style raw for cleaner edges").

Why It Sells

High-quality raw prompts are hard to find. Developers often need a "fancy" background for a portfolio or a dashboard mockup but lack the artistic eye to generate it themselves. You are selling the shortcut.

3. The "No-Code" Workflow Builder

If you are a freelancer, you likely use tools like Zapier, Make.com, or n8n to handle client onboarding, lead capture, or data syncing.

You probably have a workflow that runs perfectly for you, but you know other freelancers struggle with these same integrations.

The Product

A workflow template file. If using Zapier, this is a JSON export or a CSV import file. If using n8n, it is a JSON JSON export of the node graph.

How to Build It

Build a robust workflow in your automation tool.
Test it to ensure it doesn't error out.
Export the workflow configuration.
Create a simple landing page explaining what the automation does and why it saves time.

Why It Sells

Automation is valuable. A freelancer paying you $50 for a template saves themselves 5 hours of debugging a connection error. It is a high-value, low-effort product because you are selling the solution to a problem that already exists in your own daily workflow.

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot

5 Micro-Digital Products Anyone Can Sell From Their Phone

holdi — Thu, 15 Oct 2026 10:46:44 +0000

Selling digital products isn't reserved for SaaS founders or VC-backed startups. You do not need a degree in design, a dedicated studio, or months of development time.

You can create value, build a passive revenue stream, and sell it entirely from your phone. The barrier to entry is low, but execution matters. You need to find a specific, small problem and solve it perfectly.

Here are five concrete digital product ideas that fit a freelance workflow and can be sold via an automated store.

1. The "Serverless" SSH Config

Developers love clean, working environments. A messy ~/.ssh/config file is a common source of frustration.

Create a package that provides a pre-configured SSH configuration file. It should handle:

Local connections to a specific VPS.
Jump hosts (Bastion servers) for multiple environments (Dev, Staging, Prod).
Compression settings for faster transfer speeds.

How to sell it:
Write a quick markdown file explaining how to backup their existing config and replace it with yours. Offer a couple of variations (e.g., "The Minimalist" vs. "The Power User"). Price it at $3–$5. Delivery is a simple download link.

2. Visual Snippet Libraries

Freelancers spend hours creating UI snippets—buttons, cards, or data tables—just to reuse them later.

Create a "Design System in Code" pack. This isn't a massive library of generic buttons. It is a curated set of high-fidelity HTML/CSS snippets specific to a niche (e.g., a SaaS dashboard pack or a Fintech transaction list).

How to sell it:
Package the HTML/CSS into a neat folder structure. Include a README file that explains how to use the classes. If you are a freelancer, your clients will pay a premium for code that looks finished without the setup time.

3. The "Zero-Dependency" Bash Tool

Many developers hate complex setups. They just want to run a command to restart their local server or clear their cache.

Write a small Bash script that performs a single, repetitive task on their machine.

Example: A script that deletes .DS_Store files recursively across a project.
Example: A script that aliases npm install to npm i --legacy-peer-deps for a specific old project.

How to sell it:
Provide a single .sh file and a screenshot showing the command output. Charge $2. The value is in saving them 10 seconds of typing every time they open a project folder.

4. Automated WordPress/Headless Tweaks

If you work with WordPress or headless CMS setups, you likely know specific JSON endpoint structures or shortcode hacks that simplify content entry.

Sell a "CMS Cheat Sheet." This is a text-based PDF or Markdown file containing:

Common GraphQL queries for your specific theme.
Shortcode snippets for popular plugins.
Snippets for WP-CLI that speed up common workflows.

How to sell it:
These are reference tools. You don't need to reinvent the wheel; you just need to organize the obscure knowledge you already have into a searchable format. Price it at $4–$8.

5. Pre-Built Content Models

Copywriting is one of the highest-value skills for freelancers. But generating the structure for content takes time.

Sell a "Content Framework" pack. These are text templates for specific content types. For example, a "SaaS Feature Launch" template that includes: Headline formulas, User Persona hooks, and a bulleted list of pain points to address.

How to sell it:
A simple Notion file or a text file with clear headers. Developers and copywriters are often bad at planning; they just want a map. Give them the map for $5.

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot

Selling Digital Products in 2026 Without Ads: The Zero-Spend Playbook

holdi — Wed, 14 Oct 2026 11:03:36 +0000

If you are reading this, you likely have a product—a code pack, a design template, a curated dataset, or a set of digital notes—and you want to sell it. The traditional advice is to throw money at Google Ads, Facebook, or TikTok. That advice is still valid, but in 2026, it is an "expensive experiment." For most independent creators, it’s a way to lose money before you make a sale.

In 2026, the internet is no longer a giant billboard; it is a network of hyper-specialized communities. If you sell digital goods, you don't need a megaphone. You need a bridge. Here is how to sell digital products with zero ad spend by leveraging algorithmic discovery, community authority, and niche distribution.

1. Focus on Problem Solving, Not "Templates"

The first mistake creators make in 2026 is selling "templates." A generic Figma kit or a Notion dashboard is a commodity. There are thousands of them. To sell with zero ad spend, you must sell a specific solution to a specific pain point.

Stop making things for everyone. Make them for the 0.01% who have exactly your problem.

Example:
Instead of a "Developer UI Kit" (generic), create a "React Component Library for Rust Developers." Instead of a "Productivity Planner" (generic), create a "Content Calendar specifically for devs who want to blog but hate writing."

When you sell a solution, people share it. When you sell a template, people copy it.

2. Leverage the "Algorithmic Affiliate" Model

Organic social media (X/Twitter, LinkedIn, BlueSky, Threads) is alive and well, but it works differently than it did in 2018. The goal is no longer to build an audience; it is to find the audience.

Write content that solves the exact problem your product solves, but before you offer the solution. This is the "anti-sales" approach.

The Mechanism:

Identify a common bug or inefficiency in your niche.
Write a post explaining why the standard way is wrong.
Provide a minimal code snippet or workflow that fixes it.
Hint that a "cleaner version" exists in your paid pack.

By giving value first, you become an authority. You are not selling; you are helping. When you finally link to your store, it feels like a continuation of the conversation, not an interruption.

3. Own the "Dark Social" Channels

Marketing budgets are shifting away from public feeds toward private channels. In 2026, dark social is the primary driver of conversion for digital goods. These are conversations that happen in WhatsApp groups, Discord servers, and Telegram channels that search engines cannot index.

Your job is to get into the rooms where your customers hang out.

Actionable Steps:

Discord: Don't just join and spam. Find server admins. Offer them a commission on every sale made via their invite link.
Telegram: Join niche groups. Share your best content for free, then offer the "pro" version to members. Many Telegram users prefer direct transfers over credit cards. Set up an automated bot to handle delivery.

4. Build a "Conceptual" Landing Page

You do not need a flashy website with a mission statement and a stock photo of a laptop. You need a single, high-conversion page that focuses on the result, not the features.

Your landing page is just a README.md file or a single HTML file. It should include:

The Problem: "Stop wasting 4 hours setting up your dev environment."
The Solution: "My pre-configured Docker setup."
The Proof: A screenshot of a clean terminal.
The Link: Direct to the checkout.

Keep the friction low. The closer the click is to the value proposition, the more sales you will make.

5. The "Buy Me a Coffee" Wrapper

Processing payments can be a headache. Stripe and PayPal have strict KYC requirements and can freeze accounts. In 2026, many creators are moving away from centralized gateways entirely for small digital sales.

Wrap your product in a "instant payment" platform. This allows you to bypass KYC hurdles and reach users in regions where credit cards are difficult to obtain. The user pays via crypto or direct transfer, and the platform delivers the product instantly.

This creates a flywheel effect. High conversion rates lead to better visibility in these closed ecosystems.

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot

How to Deliver Digital Downloads Automatically with No Backend

holdi — Tue, 13 Oct 2026 13:24:29 +0000

Many developers and freelancers struggle with "middle-man" friction. You build a website, you get a client's payment, but you still have to manually log in to your file hosting service (Google Drive, Dropbox, AWS S3) to find the file, zip it, upload it to a download host, and send the link.

If you are charging for digital products, this workflow is inefficient, prone to human error, and unscalable. You do not need a custom backend server or expensive API keys to solve this.

You can automate the entire delivery pipeline using a no-code "worker" and a public folder. This approach is cheap, transparent, and requires zero server maintenance.

The Architecture: A "Dummy" Backend

The secret lies in how we treat a cloud storage folder as a database.

The Source: You host your files on a cloud provider like Google Drive, Dropbox, or Amazon S3.
The Trigger: You use a third-party automation service (like Zapier, Make, or Pabbly Connect).
The Delivery: The automation service generates a direct, time-limited or permanent download link for the file and sends it to the customer via email or chat.

This removes the need for you to be involved in the transaction. The files sit safely in your storage; the automation service acts as the bridge between "Paid" and "Downloaded."

Step 1: Prepare Your Digital Assets

Before setting up automation, ensure your files are ready to be distributed.

Security: Use password-protected ZIP files for sensitive assets (source code, templates). This prevents casual piracy.
Hosting: Do not upload raw images or large PDFs directly to your hosting provider (like Netlify or Vercel) as static assets, as they often have size limits or strict hotlinking protection. Use a dedicated cloud storage service like Google Drive or Dropbox.
Naming Convention: Create a clear naming convention for your files. If your automation script expects a specific file name, stick to it strictly.

Step 2: Connect Your Payment Gateway

You need a payment processor that triggers the automation.

For most developers and freelancers, Stripe is the standard choice. It offers a very robust API and integrates well with Zapier/Make.

Create a Product: In Stripe, set up a product with a price.
Webhooks: Enable Webhooks in your Stripe dashboard. You need to subscribe to the checkout.session.completed event. This event fires whenever a customer successfully pays.

This is your trigger. The moment money hits your account, Stripe will notify your automation tool.

Step 3: The Automation Workflow (Zapier Example)

We will use Zapier for this example because it is the most user-friendly interface for this specific task.

Trigger: Choose Stripe as the source. Select "New Successful Payment" (or the specific checkout event).
Action: Connect Google Drive (or Dropbox). Create a new file action that creates a link.
Combine: Use the data from the Stripe event to dynamically create a personalized download link.

Here is the practical logic you need to understand:

Input: Stripe provides the customer_email and the price_id.
Mapping: You tell the automation to take the price_id (which matches your product name) and find the corresponding file on your Drive (e.g., Project_Zip_V1.zip).
Output: The automation generates a direct link to that file.

Step 4: The "No Backend" Delivery Method

Here is where we remove the backend complexity. Instead of having the automation tool host the file temporarily, we use a "permissive" folder.

The Strategy:
We use a folder in Google Drive (or Dropbox) that is set to "Anyone with the link can view."

The Link: You generate a link to a specific file inside that folder.
The URL: It looks like https://drive.google.com/file/d/[FILE_ID]/preview.
Expiration (Optional): If you want to restrict access, you can use a "download as" script or set a short expiration timer in the automation logic. However, for most digital products (fonts, templates, presets), a permanent link is fine because the file is password-protected anyway.

Zapier and Make are excellent at grabbing these public links and placing them directly into the email body or chat message.

Step 5: Handling Updates and Versioning

One common fear is version control. If you update your digital product, will the old customers get the new file?

The Fix: You should version your files strictly.

Old product: Design_System_v1.zip
New product: Design_System_v2.zip

You must set up separate workflows for each version. When a customer pays for the "New Product," the automation grabs the link for v2. When a customer pays for the "Old Product," it grabs v1. This keeps your distribution channel clean and accurate.

Security Best Practices

Since we are using public links, we must compensate with security on the file itself.

Passwords: Always password protect your ZIP files.
Watermarking: If you are selling graphics, embed a visible watermark. This discourages people from sharing the link publicly, which would expose your asset to everyone.
Hash Verification (Advanced): For high-value software or code, you can use a "Download Verification" service that checks the file hash against the client's request, but for 99% of freelancers selling presets or templates, password protection is sufficient.

Summary

You do not need a Node.js server to handle digital downloads. By leveraging the APIs of your payment processor and a no-code automation tool, you can build a reliable, hands-off delivery system.

Stripe handles the money.
Zapier/Make handles the logic.
Google Drive/Dropbox handles the storage.
The customer handles the download.

This setup allows you to scale your freelancing business without trading time for money on every single file delivery.

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot

5 Micro-Digital Products Anyone Can Sell From Their Phone

holdi — Mon, 12 Oct 2026 14:14:46 +0000

Selling digital products usually feels like a setup for a YouTube ad: high-ticket courses, custom SaaS builds, and months of unpaid labor. The reality is often different. You don't need to code or create video courses to start making money.

You just need a phone, a few hours, and something that solves a specific, boring problem for a stranger.

Here are five concrete digital products that are easy to create, require no complex tools, and can be sold directly from your device.

1. Pre-configured "Cheat Sheets" for Developers

Developers waste hours searching Stack Overflow for the exact regex pattern or the default configuration for a specific library.

Create a clean PDF or text file containing 10–20 "copy-paste" blocks of code. Don't explain them; just give the code and a one-line comment. If you know PHP, curate the most common date formatting functions. If you are into Python, bundle a list of common requests headers for web scraping.

The Format: A well-formatted PDF (you can write this in Notion, export as PDF, and clean it up in Canva).
The Price: $3 – $5.
The Selling Point: "Stop Googling. Just copy."

2. Ready-to-Use Audio Loops for Content Creators

YouTubers and streamers need music loops that are royalty-free and loop perfectly. They often pay for these to avoid copyright strikes.

If you have access to a keyboard or a DAW on your phone (like GarageBand or FL Mobile), record a 30-second loop of lo-fi beats or upbeat background music. Export it as a high-quality MP3.

The Format: An MP3 file.
The Price: $5 – $10.
The Selling Point: "Royalty-free audio for your next video."

3. Prompt Templates for AI Tools

With ChatGPT and Midjourney exploding in popularity, people are desperate for better results but don't know how to talk to the AI.

Create a simple text file containing the "system prompts" you use to get high-quality outputs. Include instructions like "You are a senior copywriter," or "Create a minimalist logo concept." Organize these into a structured list.

The Format: A Markdown text file or a Notion page link.
The Price: $2 – $4.
The Selling Point: "Skip the trial and error. Use these proven prompts."

4. Pre-made Color Palettes & UI Kits

Designers and developers need colors that match. Hand-creating palettes is tedious. Create a pack of 10-15 curated color hex codes that work well together (e.g., "E-commerce Dark Mode" or "SaaS Blue").

The Format: A shared Google Drive link containing a CSS file and a text file with the hex codes.
The Price: $1 – $3.
The Selling Point: "Save hours on UI design."

5. Pre-answered Email Templates for Freelancers

Freelancers hate writing the same emails over and over: the "I don't have the budget" rejection, the "We are extending the timeline" update, and the "Welcome to the project" email.

Write these five emails in a professional tone. Save them as a PDF. Sell it as "The Freelancer's Reply Bank."

The Format: A clean PDF.
The Price: $5.
The Selling Point: "Professionalize your inbox in 5 minutes."

How to Sell This Without a Website

You don't need to set up Shopify or host a landing page. The easiest way to handle this on your phone is through a messaging app with a built-in store.

Set up a Telegram bot. Upload your files to the bot. The bot can be programmed to send the file immediately after a payment is received. This removes the need for you to manually email files to customers.

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot

How to Build a Zero-Cost Automated Store Using a Telegram Bot

holdi — Thu, 08 Oct 2026 12:41:39 +0000

Many developers overcomplicate e-commerce. They look at Stripe integrations, massive Shopify storefronts, and server infrastructure.

For selling digital assets—like API keys, PDF guides, or crypto tokens—this is unnecessary bloat.

You can build a functional, persistent store that costs $0 to run using only a free Telegram account and a standard Linux server. No credit cards required for the infrastructure.

Here is the practical guide to building a fully automated digital store using a Telegram bot.

The Architecture: A Simple Script

We are going to build a script that uses the python-telegram-bot library. This approach replaces the need for a separate web server or payment gateway.

The flow is linear:

User types /buy in a chat.
Script sends a message with a Product Link (for example, a FileSend link).
User clicks the link.
Script instantly receives the link, unlocks the file, and confirms the purchase.

Step 1: Set Up the Server

You need a place to host the bot. Do not use a shared web hosting panel like cPanel unless you know how to set up cron jobs. A cheap VPS (Virtual Private Server) is best.

Option A: A $5/mo DigitalOcean Droplet.
Option B: A free tier Render or Railway app.

For this guide, we will assume a standard Linux environment where you have pip and python3 installed.

Step 2: Configure the Telegram Bot

You don't need a Telegram Premium account to build this, but a Premium account gives you the "Edit Message" feature, which is crucial for automated receipts.

Open Telegram and search for @BotFather.
Send /newbot.
Name your bot (e.g., "M3LM Hermes").
Choose a unique username (e.g., m3lm_hermes_bot).
Copy the API Token.

Save this token securely in your environment variables. Never hardcode it in your script.

Step 3: The Python Script

Create a file named store.py. We will use the io module to simulate file delivery and the python-telegram-bot library to handle the API.

This script handles the logic for a single product: a "Crypto Pack."

import logging
import os
import random
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import Application, CommandHandler, MessageHandler, CallbackQueryHandler, filters, ContextTypes

# Enable logging
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)

# --- CONFIGURATION ---
TOKEN = os.getenv("TOKEN", "YOUR_BOT_TOKEN_HERE")
# We simulate a product file. In reality, this would be a link to a file hosted on a storage service like DropBox, Mega, or Google Drive.
PRODUCT_LINK = "https://example.com/digital-pack.zip"
# A fake price to display on the button
PRODUCT_PRICE = "$10.00"
# --- END CONFIGURATION ---

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "Welcome to the M3LM Store. Use /buy to purchase the Crypto Pack."
    )

async def buy_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    # Create the inline keyboard with a link
    keyboard = [[InlineKeyboardButton(f"Buy {PRODUCT_PRICE} Pack", url=PRODUCT_LINK)]]
    reply_markup = InlineKeyboardMarkup(keyboard)

    await update.message.reply_text(
        "Select the link below to proceed with payment and instant delivery:",
        reply_markup=reply_markup
    )

async def handle_purchase_confirmation(update: Update, context: ContextTypes.DEFAULT_TYPE):
    # This function is triggered when the user clicks the link.
    # In a real scenario, you would check for a webhook or a callback query here.

    user = update.effective_user
    chat_id = update.effective_message.chat_id

    # Here you would verify payment with a service like LemonSqueezy, Stripe, or manual wallet transfer.
    # For this example, we assume the link was clicked successfully.

    # Send the file
    try:
        # In a real app, you would use context.bot.send_document or send_photo
        await update.message.reply_text(
            f"Payment verified for {user.full_name}. \n\nDelivering your package..."
        )
        await update.message.reply_text("Click the link below to download your Crypto Pack:", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("Download File", url=PRODUCT_LINK)]]))
    except Exception as e:
        await update.message.reply_text("Failed to deliver the file. Please contact support.")

def main():
    # Build the application
    application = Application.builder().token(TOKEN).build()

    # Add handlers
    application.add_handler(CommandHandler("start", start))
    application.add_handler(CommandHandler("buy", buy_command))
    # We use a MessageHandler to catch text messages for this simplified example
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_purchase_confirmation))

    # Run the bot until the user presses Ctrl+C
    application.run_polling()

if __name__ == "__main__":
    main()

Step 4: Deploy and Run

Do not run this locally. It will go offline when you close your terminal.

Save the file.
Install the library:
```
pip install python-telegram-bot
```
Run the bot in the background. On a Linux VPS, you can use nohup:
```
nohup python3 store.py > bot.log 2>&1 &
```
Check logs periodically to ensure no errors occur.

Step 5: Handling the Delivery

The trickiest part of this architecture is the "click-through" flow.

When the user clicks "Buy $10 Pack," they leave the Telegram app. This is the only friction point.

To make this truly zero-cost, you do not need a payment processor. You can sell via:

Manual Wallet Transfer: User sends USDT to your wallet, sends you a screenshot, and the bot automatically detects the transfer and sends the file.
Direct Links: User pays outside Telegram (Stripe/LemonSqueezy), receives a code, and pastes it into the bot.
Encrypted Links: You host files on a free cloud drive (like Google Drive) and use a script to generate expiring links (using a library like pyfilesharing).

The handle_purchase_confirmation function in the script above is where you implement the logic to unlock the link.

Maintenance and Scaling

This script is stateless. This is good. It means you can restart the bot, and the store won't break.

However, for scale, you will eventually need a database (like SQLite or PostgreSQL) to store user IDs and inventory levels. For a "zero-cost" initial launch, simple text files or the built-in sqlite3 library in Python are sufficient.

I sell these kinds of digital packs in a tiny automated Telegram store - instant USDT delivery. Check it: https://t.me/m3lmhermes_bot