How to set up a paid Telegram channel with Nemiling

Alex Manner — Tue, 25 Aug 2026 19:32:11 +0000

How to set up a paid Telegram channel with Nemiling
Setting up a paid Telegram channel sounds simple at first: someone pays, gets access, and loses that access when the subscription expires. Nemiling will ask you to create a PayPal REST API application. Open PayPal's My Apps & Credentials page, create a new app, choose the Merchant app type, then copy the Client ID and send it back to @Nemilin_bot. Continue following the bot's prompts until it confirms that PayPal has been connected successfully.

In practice, there are a few moving parts involved. You need to connect the channel, create subscription plans, set up a Telegram bot, connect a payment provider, and make sure payment notifications work correctly. I decided to go through the whole process myself and document it step by step.

Step 1. Create a project
Open @Nemilin_bot and go to the projects section in the bottom menu.
Nemiling is a platform for automating monetization and access management for Telegram channels and groups.
The first message appeared in Russian, but the bot immediately asks you to choose your preferred language. After selecting English, the rest of the setup is displayed in English. The language selector is straightforward, so this shouldn't cause any problems. (1st Figure)
(1st Figure)

Click “Create a new project” and choose the project type you want to set up (2nd Figure)
(2nd Figure)

The bot will then ask you to:
enter a name for the new project;
choose the resource you want to connect.
In this case, the resource is a Telegram channel. (3rd Figure) (3rd Figure)

You can think of the project as the foundation of the setup. Later, the Telegram channel, subscription plans, and other paid-access settings will all be connected to it.

Step 2. Connect the Telegram channel
Once the project is created, open the Telegram channel you want to monetize. Go to the channel's administrator settings and add @Nemilin_bot as an administrator.

If your channel has a linked discussion group, follow the additional instructions shown by the bot and make sure it has the required permissions there as well. (4th Figure) (4th Figure)
The permissions shown in the setup include the ability to manage subscribers, including adding and removing them.
This makes sense: if the system is going to grant access after payment and revoke it when a subscription expires, it needs permission to manage channel members.
Next, return to @Nemilin_bot and forward any message from the channel you just connected.
This lets Nemiling verify that it actually has access to the correct Telegram resource.
If everything is configured correctly, the bot will confirm the connection and offer to continue with subscription-plan setup. (5th Figure)
(5th Figure)

Step 3. Configure a subscription plan
Now it's time to define what the subscriber is actually buying.
When creating a plan, you need to specify:
currency;
plan name;
subscription duration;
price;
resources that become available after purchase.

(6th Figure)

For example, you can create a plan that provides access for one month.
You don't have to stop at a single option. If you want to offer different conditions, you can create several plans with different prices or subscription periods.
Once the plan is configured, click Save.
When all required plans are ready, click “Next Stage”. (7th&8th Figure) (7th Figure)(8th Figure)

Step 4. Create your own bot with BotFather
At this point, one question may come up:
We're already configuring everything through @Nemilin_bot. Why do we need another bot? (9th Figure)(9th Figure)
@Nemilin_bot is the interface used to configure the Nemiling platform itself.
Your project, however, gets its own Telegram bot.
Open the official @botfather and send:
/newbot

BotFather will ask you to:
choose a bot name;
choose a username.

The username must end with bot.
After the bot is created, BotFather will give you an API token that looks roughly like this:
123456789:ASDFABC-DEF1234gh
Copy the token and send it to @Nemilin_bot.
One important point from the original setup instructions: it's better to create a separate bot for Nemiling rather than reuse a bot that is already connected to another service.
And, of course, never publish your real API token in an article, repository, or screenshot.

Step 5. Connect a Payment Provider
The next step is accepting payments.
The setup I followed uses PayPal as the example payment provider.
In Nemiling, select PayPal and click the option to connect it. Nemiling will ask you to create a PayPal REST API application. Open PayPal's My Apps & Credentials page, create a new app, choose the Merchant app type, then copy the Client ID and send it back to @Nemilin_bot. Continue following the bot's prompts until it confirms that PayPal has been connected successfully.

For this integration, you'll need an eligible PayPal business account in a country where PayPal operates.

If you run into problems during setup, contact Nemiling support.
Continue following the prompts in @Nemilin_bot until the bot confirms that the payment provider has been connected successfully.
The project exists, subscription plans are configured, and Nemiling can automate the routine parts of paid access to the connected Telegram channel.

What Nemiling Automates
In this setup, Nemiling sits between payment processing and access management for the Telegram resource.
The subscriber chooses a plan and pays for it.
After that, the channel owner doesn't have to manually check every transfer or manage access for every new subscriber.
The platform automates the routine parts of paid access.
The money is not accumulated on an internal Nemiling balance waiting for a separate withdrawal. It goes through the connected payment provider to the creator's account.
Nemiling doesn't charge a percentage of each payment. Instead, it uses subscription plans based on the account's monthly turnover.
In this article, I deliberately focused on just one use case: running a paid Telegram channel with subscriptions.
Nemiling also supports other monetization scenarios, including paid messages, paid consultations, and donations, but those deserve separate walkthroughs.
The setup involves several services, but each individual step is straightforward. The important part is testing the entire flow — from choosing a plan to receiving access — before sending the bot to real subscribers.

What I’m Learning While Exploring Telegram Bots with Python

Alex Manner — Mon, 24 Aug 2026 08:30:06 +0000

Hey DEV community!
I’m still early in my journey with Python and Telegram bots, but one thing has already become clear: building a useful bot is much more than sending a message back when someone types a command.

At first, the basic flow looks simple:

User sends a message
↓
Bot receives it
↓
Some Python code runs
↓
Bot sends a response

Then you start thinking about a real product. Suddenly there are users, states, databases, payments, permissions, errors, background tasks, and integrations with external services.

That’s where things get much more interesting.

The Telegram API is only one part of the system It’s easy to think of a Telegram bot as “a program inside Telegram.”

In practice, Telegram is mostly the interface. Behind the bot you may still need:

application logic;
a database;
authentication;
an external API;
payment processing;
logging;
monitoring;
deployment.

State becomes important very quickly. For a simple command like /help, you don’t need much context. But imagine a user going through a multi-step process:

Choose a plan
→ enter some information
→ confirm
→ pay
→ receive access

Now the bot needs to know where that user currently is in the process.

Did they already choose a plan?

Did the payment succeed?

Should they still have access?

What happens if they leave halfway through and come back tomorrow?

Payments make everything more serious A bug in a weather bot is annoying. A bug involving money is different.

Once payments are involved, you need to think about things like:

duplicate events;
failed payments;
delayed confirmations;
retries;
expired access;
what happens when an external service is unavailable.

The interesting work starts with: What happens when something goes wrong?

Automation creates another problem: trust

The system needs to be reliable enough to make decisions on its own.

For example:

Payment confirmed
↓
Grant access
↓
Track expiration
↓
Remove access if necessary

If any part of that logic is wrong, the bot can affect a real user without a human being involved.

That makes logging, testing, and good error handling much more important than I initially expected.

Small projects are a good way to learn architecture

I used to associate software architecture with large systems and big engineering teams.

Now I’m starting to see that the same questions appear surprisingly early:

Where should business logic live?
What should the Telegram handler be responsible for?
What belongs in the database?
How should external integrations be isolated?
What happens if one service goes down?

You don’t need thousands of users before these questions become useful.

Even a small bot can teach you a lot about designing systems.

I’m especially interested in the point where a small Telegram bot starts turning into a real product. If you’ve built Telegram bots before, I’d be curious to know:
what was the first problem that made you realize your bot was becoming a “real” software project?

DEV Community: Alex Manner

How to set up a paid Telegram channel with Nemiling

What I’m Learning While Exploring Telegram Bots with Python