How to Automate Daily Content Translation and Publishing with n8n

The Daily Content Tax

If you run a publication, a newsletter, or any kind of content operation that spans languages or channels, you know the daily content tax. Something gets published in one place. Someone manually copies it, pastes it into DeepL, edits the translation, reformats it for LinkedIn, reformats it again for the blog, schedules it somewhere, and 2 hours later you have one piece of content in two places.

Multiply that by 5 pieces per day and a content manager is spending 2-3 hours daily on mechanical work that has nothing to do with judgment or creativity.

This post walks through the n8n workflow we use to automate daily content translation and publishing. The setup covers: pulling content from an RSS feed, filtering for relevance, running translation through DeepL, rewriting tone with OpenAI, queuing posts for staggered publishing, and adding a human review step with Telegram approve/reject buttons. Every node name is real, not pseudocode.

Step 1: Getting the Content (RSS Trigger or Webhook)

The first node depends on where your source content lives.

If you're pulling from an existing blog, news source, or any site that publishes an RSS feed, use n8n's built-in "RSS Feed Trigger" node. Configure it to poll at your desired frequency. For daily content workflows, polling every 15-30 minutes is usually right. Set it shorter and you'll trigger on content faster; set it to every 6 hours and you risk batching too much at once.

The RSS Feed Trigger node gives you the item's title, link, content, pubDate, and usually a summary. The content field is where the article body lives, though some RSS feeds only include a snippet and require a follow-up HTTP Request to the article URL to pull the full text.

If your source isn't RSS but you control the publishing side (your team posts in Notion, for example, or someone submits via a form), use a Webhook node instead. Trigger it from wherever the content originates and pass the payload directly into the workflow. This is more reliable than polling and reacts to content immediately.

For Google Alerts, Google doesn't offer a proper webhook but does offer RSS output for any alert. Go to google.com/alerts, set up your alert, select "RSS Feed" as the delivery method, copy the feed URL, and use it as your RSS source in n8n.

Step 2: Filtering for Relevance

Not everything in an RSS feed is worth translating and publishing. Most sources mix content types: some pieces are relevant to your audience, others aren't. If you publish everything without filtering, your channels fill with noise.

The cleanest filtering approach in n8n is a combination of an "IF" node and an "OpenAI" node.

The simple version: use an IF node to check whether the title contains specific keywords (your topic keywords, product names, competitor names) or whether the source URL matches your expected domains. This works for simple cases where you have clear keyword rules.

The more reliable version: send the title and summary to an OpenAI Chat node with a prompt like: "Is this article relevant to [your topic]? Reply only YES or NO." Then use an IF node to check whether the response is YES. This costs fractions of a cent per item and is far more accurate than keyword matching for nuanced relevance decisions.

If OpenAI returns YES, the item continues through the workflow. If NO, the item routes to a Stop node or a "log rejected items" Google Sheets row. Check that sheet weekly, you'll learn where your filtering is too tight or too loose.

Step 3: Translation via DeepL API

DeepL's API produces better translations than Google Translate for most European language pairs. For technical content, marketing copy, and anything where tone matters, the quality difference is noticeable.

In n8n, use the "HTTP Request" node to call DeepL's translation endpoint directly. DeepL doesn't have a native n8n node (as of n8n version 1.42, which was the current release when we last checked), so you use HTTP Request with the following configuration:

• Method: POST
• URL: https://api-free.deepl.com/v2/translate (for the free tier) or https://api.deepl.com/v2/translate (for Pro)
• Body type: Form-Data or JSON
• Parameters: text (your article content), target_lang (your destination language code, e.g. DE, ES, PT-BR), source_lang (optional, omit to let DeepL detect automatically)
• Header: Authorization: DeepL-Auth-Key YOUR_API_KEY

The response comes back as JSON. The translated text lives at response.translations[0].text. Map that to a new field you'll carry through the rest of the workflow.

One thing to configure: DeepL has request size limits. The free tier accepts up to 128KB per request. A long article that exceeds this will fail silently if you don't handle it. Add a Code node before the DeepL call that checks string length and trims content if needed, or splits very long articles into chunks and makes multiple calls.

Step 4: Rate Limiting the API Calls

DeepL's free tier allows 500,000 characters per month. That's roughly 350-400 medium-length articles. More than enough for most setups. The Pro tier is character-based with no monthly cap, billed per million characters.

The issue is not hitting monthly limits. It's hitting DeepL's rate limits on rapid concurrent requests. If your RSS feed publishes 10 articles at once and your workflow processes them in parallel, 10 simultaneous DeepL calls can trigger a 429 (Too Many Requests) response.

Fix this in n8n by setting the "Loop Over Items" node's batch size to 1 and adding a Wait node (set to 2 seconds) after each DeepL call. This slows down the processing but prevents rate limit errors. For 10 articles, total processing time is 20 seconds. Perfectly acceptable for a content workflow.

If you're on n8n's queue mode, you can also configure the worker concurrency to limit how many executions run simultaneously, which handles this at the infrastructure level rather than inside the workflow.

Step 5: Rewriting Tone with OpenAI

The translated text from DeepL is accurate but often reads literally. For publishing to LinkedIn or a branded blog, you usually want to adapt the tone: shorter sentences, an active voice, maybe a specific point-of-view or style that matches your brand.

Use an OpenAI Chat node after the DeepL step. A simple system prompt works well here. Something like: "You are an editor for [Brand Name]. Rewrite the following article to be more concise and direct, suitable for a professional LinkedIn audience. Keep all facts accurate. Write in [target language]."

Feed the translated text as the user message. The response is your publication-ready version.

Practical notes: GPT-4o is better at this than GPT-3.5 Turbo for maintaining nuance in the rewrite. The cost difference at typical daily content volumes (5-10 articles per day, 800-1,000 words each) is about $2-5 per month for 4o vs $0.20-0.50 for 3.5-turbo. For most businesses, the quality difference is worth the cost.

You can also add a second OpenAI call here to generate a short LinkedIn caption from the rewritten article. Two calls per article, but they run sequentially so it adds maybe 6-8 seconds to the workflow.

Step 6: Adding a Human Review Step

Fully automated publishing without any human check is fine for internal tools. For anything client-facing or brand-associated, one human check before something goes out is worth the time.

The slickest approach in n8n is a Telegram inline keyboard. The workflow sends a Telegram message to an approver (you, an editor, anyone with the bot) with the article preview and two buttons: "Approve" and "Reject." The workflow then pauses and waits for the button click before continuing.

Here's how to set it up:

First, create a Telegram bot via BotFather and get your bot token. Then use the "Telegram" node in n8n to send a message with inline keyboard buttons. The node configuration for inline keyboards uses the "Reply Markup" field with type "inlineKeyboard." Each button has a text label and a callback_data value (e.g. "approve" or "reject").

After sending, add a "Wait" node configured to resume on a webhook. Configure a Telegram "Trigger" node (separate from the sender) to listen for callback_query events from your bot. When the approver clicks a button, Telegram fires a callback query to your bot, n8n's trigger receives it, and the workflow resumes.

Use an IF node to check the callback_data value. If "approve", continue to publishing. If "reject", route to a Google Sheets logging node that records the rejected item with a timestamp so you can review patterns later.

The Telegram inline keyboard approach means the approver never leaves their phone. They get the message, read the preview, tap Approve, and that's it. Latency from content arrival to published (assuming immediate approval) is about 2-3 minutes.

Step 7: Staggered Publishing

Don't publish everything at once. If 8 articles come through your pipeline and get approved back-to-back, posting them all to LinkedIn in the same hour looks like spam and performs worse algorithmically.

Use a Schedule-based approach: approved items get added to a "publishing queue" Google Sheet with a calculated scheduled_publish_time. Calculate the time as: current time + (queue position x 90 minutes). Item 1 publishes now. Item 2 in 90 minutes. Item 3 in 3 hours. And so on.

A separate n8n workflow (triggered every 15 minutes by a Schedule Trigger) checks the sheet for rows where scheduled_publish_time is within the next 15 minutes and published is false. For each matching row, it publishes to the destination and marks the row as published.

This approach also gives you a simple dashboard: just look at the Google Sheet to see what's queued and when it's going out.

Step 8: Publishing to Destinations

The last step is the actual publish action. This varies by destination.

LinkedIn: Use n8n's native "LinkedIn" node with the "Create Post" operation. For articles (not just link shares), LinkedIn's API requires a specific structure. The native node handles the basics.

WordPress: Use the "WordPress" node. Create a Post operation accepts title, content, status (set to "publish" or "draft" if you want a final check in the WP editor), and category IDs.

Telegram channel: Use the "Telegram" node to send a message to your channel ID. Format the text with basic Telegram markdown (bold with *asterisks*, code blocks with backticks).

Twitter/X: As of 2024, Twitter's API access for posting requires a paid developer account ($100/month for Basic tier). The n8n "X (Twitter)" node works but check your API access level. Free tier doesn't allow posting.

If a publish call fails (API is down, auth token expired, rate limit hit), n8n will mark the execution as errored. Set up an "Error Trigger" workflow that sends you a Telegram message when any execution fails. You'll know within minutes if something in the pipeline breaks.

The Full Flow, Summarized

RSS Feed Trigger (every 30 min) -> OpenAI relevance filter -> IF node (relevant YES/NO) -> DeepL translation -> Wait (2 sec rate limit) -> OpenAI tone rewrite -> Telegram review message with inline keyboard -> Wait for approval callback -> IF (approve/reject) -> Add to publishing queue Google Sheet -> Scheduled publisher checks queue every 15 min -> Publish to destination(s).

End-to-end latency from content appearing in the RSS feed to being queued for review: about 45-60 seconds for a 1,000-word article. From approval to published: up to 15 minutes depending on where in the queue schedule it falls.

Total n8n operations per article: around 12-14 nodes, most of them HTTP calls. On n8n's cloud Starter plan (which limits active workflows, not operations), this setup uses 2 workflows (the main pipeline and the queue publisher). On self-hosted, no limits.

---

If you want us to build this for you, book a free workflow audit at airtective.com