---
title: "X post writer with Telegram approval"
kind: "Kit"
category: "Marketing & SEO"
price: "Free"
seller: "Mindket"
version: "2"
url: "https://mindket.com/p/6044bb36-10e4-4b17-a58b-dcba5dd59c23"
updated: "2026-11-09"
---

# X post writer with Telegram approval

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow that drafts posts for X from a message to your Telegram bot. The agent searches the web with Tavily and writes the draft, and nothing is posted until you approve it, by a button or by a typed reply.

X post writer with Telegram approval is an n8n workflow in the Marketing \& SEO category, listed by Mindket. It is free. This is version 2, last updated on 2026-11-09. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow writes posts for X and waits for your approval before it publishes them. You message your Telegram bot with what the post should cover. An agent searches the web through Tavily, writes a draft of up to 280 characters with its source named, and sends it back to your chat. The file holds two complete flows for that approval step. In one you press Approve or Decline. In the other you type a reply, a classifier decides whether it means yes, and a request for changes goes to a revision agent, which sends a new draft for another round. Approved text is posted to X.

You message your Telegram bot → An agent searches the web and drafts the post → The draft returns to your chat for approval → Approved text is posted to X

### Who it suits

People who post on X often, want a draft made from fresh sources, and want to keep the last word. Because the whole loop runs inside a chat, it works from a phone.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| News and media | Social editors | Send a story topic and approve the sourced draft that comes back | An editor sends a topic from a phone and approves the sourced draft in the same chat. |
| Software and developer tools | Founders who post updates | Use the typed-reply flow to trim a draft until it reads right | A founder replies with a request for a shorter version and approves the second draft. |
| Creators and newsletters | Solo creators | Keep one account active between other work, with each post approved first | A creator sends one topic between meetings and posts only what they approved. |
| Marketing teams | Community managers | Give the draft agent a different tone in its system message | A manager rewrites the agent’s style rules once, and each draft follows them. |

Skip it if you want posts on a schedule or a content calendar. This answers one message at a time and has no queue.

### Where to use it

An n8n with a public HTTPS address, because Telegram sends your bot’s messages to it.

- n8n Cloud or your own server: import the file and publish it, so the bot’s messages reach the triggers
- Telegram: the chat with your own bot is where requests, drafts and replies happen
- X: approved posts go to the account you connect
- Search and models: Tavily finds the sources and OpenRouter runs the language models

### How to set it up

Get it saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Have these ready before you import it.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or on a server with a public HTTPS address |
| Telegram | A bot, made in Telegram with BotFather, and its token |
| Tavily | An API key, kept in n8n as an HTTP Header Auth credential |
| OpenRouter | An API key for the three chat models |
| X | A developer app with OAuth 2.0, its Client ID and Client Secret, and write access |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Add a Telegram credential with your bot token and select it in `Telegram Trigger`, `Submit Approval`, `Denial message`, `Telegram_Trigger` and `Request Feedback`.
3. Add an HTTP Header Auth credential with the header `Authorization` and your Tavily key, and select it in `Tavily` and `Tavily Search`.
4. Add an OpenRouter credential and select it in `GPT 4.1`, `GPT_4.1` and `2.0 Flash`.
5. In the X developer portal, make an OAuth 2.0 app and give it the callback address n8n shows on the credential. Add an X OAuth2 credential with the Client ID and Secret, then select it in `X` and `X Post`.
6. Read the note on bots under Good to know, then choose which flow to keep.
7. Save, press Publish, and message your bot.

### How to use it

Message the bot with what the post should cover. The agent searches, drafts, and sends the draft back to the same chat. How you answer depends on the flow.

The two approval flows

| Flow | You answer | If you approve | If you do not |
| --- | --- | --- | --- |
| Yes or no, from \`Telegram Trigger\` | Two buttons, Approve and Decline | The draft is posted to X | A short message says it was denied, and the run ends. Send a new request to try again |
| Typed reply, from \`Telegram\_Trigger\` | Any text | A classifier reads it, and approval posts the draft | A request for changes goes to the revision agent, and a new draft comes back for another round |

### Example

A message to the bot, and the typed-reply flow:

```text
You: a post about this week’s Mars rover news
Bot: Good to go? <the draft, up to 280 characters, with its source named>
You: make it shorter
Bot: Good to go? <the shorter draft>
You: looks good
```

The last reply makes the classifier answer approved, and the latest draft is posted to X.

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. Notes on the canvas group this file into its two flows and label each stage, such as `Initial Content`, `HITL`, `Decision Point`, `Post` and `Revision`. Start with the yes or no flow, since it has fewer parts.

**For experts.** Models run through OpenRouter, and each role has its own node.

Who does what

| Role | Model | What to know |
| --- | --- | --- |
| Draft agents | OpenAI GPT-4.1 | The prompt requires a Tavily search every time and asks for a source named in the text, with no @ sign |
| Revision agent | OpenAI GPT-4.1 | It has no search tool, so a revision cannot look up new facts |
| Text classifier | Google Gemini 2.0 Flash | Two categories, approved and declined, each with sample phrases |
| Search | Tavily, through an HTTP tool | Asked for one result per query, with a short answer |

### Good to know

A post is public, so the approval step is the only thing between a draft and your followers.

- One bot, two triggers: Telegram sends a bot’s messages to a single webhook address, so two triggers on the same bot compete. Give the second flow its own bot, or delete the flow you do not use
- Length: the prompt asks for 280 characters or fewer, and nothing in the workflow checks it
- Waiting: neither approval step sets a time limit, so an unanswered draft keeps waiting
- Replies: the answer opens a page served by your n8n, so the reviewer’s phone must be able to reach its address
- Costs: OpenRouter bills each draft and each classification, and Tavily bills each search
- Your data: your request and the drafts reach Tavily, OpenRouter and the model providers, and approved text reaches X

## README

```markdown
# X post writer with Telegram approval

An n8n workflow. Message your Telegram bot with what a post should cover, and an agent searches the web, drafts the post and
sends it back to you. Nothing goes to X until you approve it, either with a button or with a typed reply.

## What is inside

- `workflow.json`: the workflow as n8n exports it, 34 nodes. It holds two separate flows, each with its own Telegram
  trigger. It holds no credential. Sixteen notes label the groups and stages, and one of them is a short setup guide.
- `README.md`: these notes.

## Before you start

- An n8n instance with a public HTTPS address, on n8n Cloud or your own server. Telegram sends your bot's messages to it.
- A Telegram bot, made with BotFather, and its token.
- A Tavily API key.
- An OpenRouter API key.
- An X developer app with OAuth 2.0 and permission to write, with its Client ID and Client Secret.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Add a Telegram credential with your bot token. Select it in `Telegram Trigger`, `Submit Approval`, `Denial message`,
   `Telegram_Trigger` and `Request Feedback`.
3. Add an HTTP Header Auth credential. Header name `Authorization`, value `Bearer ` and your Tavily key. Select it in `Tavily`
   and `Tavily Search`.
4. Add an OpenRouter credential and select it in `GPT 4.1`, `GPT_4.1` and `2.0 Flash`.
5. In the X developer portal, create an app that uses OAuth 2.0. Set its callback address to your n8n address followed by
   `/rest/oauth2-credential/callback`. In n8n add an X OAuth2 credential with the Client ID and Client Secret, finish the
   sign-in and select it in `X` and `X Post`.
6. Choose which flow to keep (see Good to know about bots), save, then press Publish at the top of the canvas (or Shift+P).
7. Send your bot a message.

## The two flows

| Flow | Starts at | You answer | Then |
|---|---|---|---|
| Yes or no | `Telegram Trigger` | Two buttons, Approve and Decline | `If` sends an approval to `X`, and a decline to `Denial message` |
| Typed reply | `Telegram_Trigger` | Any text in `Request Feedback` | `Text Classifier` sends approval to `X Post`, and a request for changes to `Revision Agent` |

In the typed-reply flow the revised draft passes through `Set Post` and comes back to `Request Feedback`, so the loop runs
until you approve. The post that goes to X is the latest one saved in `Set Post`.

## Change it

- Tone and rules: edit the system message in the draft agents (`X_Post Agent` and `X Post Agent`) and in `Revision Agent`.
- What counts as approval: the category descriptions in `Text Classifier` hold sample phrases. Add your own.
- Reviewer text: the question the bot asks sits in `Submit Approval` and `Request Feedback`, as `Good to go?` above the draft.
- Models: the OpenRouter nodes name `openai/gpt-4.1` and `google/gemini-2.0-flash-001`. Pick others in the nodes.
- Search: the Tavily tool nodes ask for one result per query. Raise `max_results` in their JSON body for more.

## Good to know

- Telegram sends a bot's messages to a single webhook address, so two triggers on the same bot compete. Give the second flow its
  own bot with its own credential, or delete the flow you do not use.
- The prompt asks for 280 characters or fewer, and nothing in the workflow checks it.
- Neither approval step sets a time limit, so an unanswered draft keeps waiting.
- The reply opens a page served by your n8n, so the reviewer's phone must be able to reach its address.
- The revision agent has no search tool, so a revision cannot look up new facts.
- OpenRouter bills each draft and each classification, and Tavily bills each search.
- Your request and the drafts reach Tavily, OpenRouter and the model providers. Approved text reaches X.
- Mindket took the author's name and channel link out of the setup note on the canvas.
```

## What is in it

2 files, 25 KB, downloaded as a zip.

```text
README.md  4 KB
workflow.json  21 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 13 steps, starting on a Telegram event
- AI: 4 steps call an AI model: X Post Agent, Text Classifier, Revision Agent and X_Post Agent
- Sign-ins: Signs in to: Tavily, Telegram, X and OpenRouter
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads 6 of its 7 step types. It does not read: Telegram

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/6044bb36-10e4-4b17-a58b-dcba5dd59c23)
- [Its page on Mindket](https://mindket.com/p/6044bb36-10e4-4b17-a58b-dcba5dd59c23)