YouTube to Email Automation (2026): RSS to Beehiiv with Make

1. Why Connect YouTube to Email?

YouTube is a distribution platform; an email list is an owned audience channel. Connecting the two means every qualifying video can become an email touchpoint without requiring the creator to rewrite the same announcement manually after publishing.

The useful goal is not “send every upload to everyone.” A better automation turns a new YouTube upload into a structured decision: Is this the type of video that should trigger an email? If yes, the workflow prepares the newsletter. If not, the video is logged and ignored.

2. Current YouTube-to-Beehiiv Architecture

Google’s official feed format uses an Atom feed with a topic URL such as:

https://www.youtube.com/feeds/videos.xml?channel_id=YOUR_CHANNEL_ID

A YouTube channel ID is not the same thing as a handle such as @YourChannel. The feed URL requires the channel ID.

3. What the YouTube Feed Actually Contains

This is where the old implementation was too optimistic. Google’s official feed example includes the information needed to identify and link a new upload, but it is not a complete YouTube API response.

Use the video ID as the canonical key

The video ID is the safest identifier for this workflow. Store it in a Make Data Store, spreadsheet, database or equivalent state layer before publishing the newsletter.

This matters because Google’s documentation says notifications can also occur when a video’s title or description is updated. Without idempotency, an automation could create another email for the same video after a metadata change.

4. Beehiiv’s Two Current Routes

Route A — Native RSS-to-Send

Beehiiv now has a native RSS-to-Send feature for external RSS ingestion. It is designed to turn external RSS content into recurring newsletter content without building a third-party automation layer.

The current Beehiiv documentation places RSS-to-Send on Max and Enterprise. If all you need is “new feed item → newsletter,” this is the simplest architecture because there is one fewer external orchestration system to maintain.

Route B — YouTube RSS → Make.com → Beehiiv Send API

Use this when the feed item needs to go through business logic first: keyword filtering, multiple publications, deduplication, CRM enrichment, AI-generated copy, conditional routing, logging or other downstream actions.

Beehiiv’s current Create Post API is also Max and Enterprise only. The endpoint is:

POST
https://api.beehiiv.com/v2/publications/pub_XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX/posts

5. Make.com vs Zapier vs n8n for This Workflow

All three can participate in this architecture, but the comparison should be made on the actual workflow mechanics rather than generic “automation platform” feature lists.

Zapier’s current YouTube integration includes a New Video in Channel polling trigger and also supports a New Video in Playlist trigger. Its Beehiiv integration exposes a custom API-call action, but its standard action list is not a simple “Create Post” button. That distinction matters when comparing a plug-and-play workflow against Make’s HTTP approach.

n8n’s current hosted pricing is based on workflow executions rather than individual steps. That can be attractive when one workflow contains many operations, but the economics are different from Make’s credit model.

6. Current Infrastructure Cost

This is where the original article was most misleading. There are really two separate cost layers: the automation engine and the newsletter publishing feature.

The practical implication is that Beehiiv’s plan is the larger gating cost for direct automatic post creation. Moving from Make Free to Make Core may improve scheduling and capacity, but it does not unlock Beehiiv’s Send API.

7. Build the YouTube → Make.com Workflow

1. 1

   Find the YouTube channel ID

   Use the channel ID rather than the public @handle. Your feed becomes:

   Feed URL

   https://www.youtube.com/feeds/videos.xml?channel_id=UCXXXXXXXXXXXXXXXXXXXXXX

2. 2

   Create the RSS trigger in Make.com

   Add RSS → Watch RSS Feed Items and paste the YouTube feed URL. Make’s RSS app is designed to monitor RSS/Atom feeds and emit feed item details.

   Use Make’s Choose where to start option deliberately. For a new production scenario, start from the current point rather than importing the historical feed unless you actually want old videos processed.

3. 3

   Use videoId as your idempotency key

   Create a Make Data Store record keyed by the YouTube video ID. Before creating a Beehiiv post, check whether that video ID has already been processed.

   Store at least: video_id, publication_id, created_at, and the resulting Beehiiv post_id.

4. 4

   Add filters before publishing

   Useful filters include title keywords, channel ID, publication destination, publication time and whether the video has already been processed.

   Do not rely on title keywords alone to identify Shorts or long-form videos. If content type matters commercially, add an enrichment step using another trusted source.

5. 5

   Generate the newsletter content

   Build the newsletter from the fields the feed actually provides: title, link, video ID and publication timestamp.

   If you need the full description, transcript, duration, categories or other metadata, enrich the record before sending it to Beehiiv.

6. 6

   Send the content to Beehiiv

   On eligible Max/Enterprise accounts, use the Create Post endpoint. For safest operations, create a draft first rather than automatically sending every upload.

8. Correct Beehiiv Create Post API Request

The current Beehiiv API expects the publication identifier in the URL with the pub_ prefix and uses Bearer authentication. The Create Post endpoint accepts either blocks or body_content.

POST https://api.beehiiv.com/v2/publications/pub_XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX/posts

Authorization: Bearer YOUR_TOKEN
Content-Type: application/json

{
  "title": "New video: {{video_title}}",
  "subtitle": "Watch the latest upload",
  "status": "draft",
  "body_content": "<p><a href='{{video_url}}'><img src='{{thumbnail_url}}' alt='{{video_title}}' width='100%' /></a></p><p><a href='{{video_url}}'>Watch the video →</a></p>"
}

Want fully automatic sending?

The current API also supports status: confirmed. Without a scheduled_at value, that publishes immediately; with a scheduled time, it can publish at the scheduled time.

201 Created does not mean the post is already finished

Beehiiv’s current API creates posts asynchronously. The Create Post request can return 201 with the new post ID while Beehiiv is still processing it.

If you immediately retrieve that post and receive 202, wait and honor the Retry-After response. If background creation ultimately fails, Beehiiv documents a POST_CREATION_FAILED condition.

Make → POST Create Post
       ↓
HTTP 201
       ↓
Beehiiv processes post asynchronously
       ↓
GET post when verification is needed
       ↓
200 = ready
202 = still processing
404 + POST_CREATION_FAILED = creation failed

9. Do Not Put a Live YouTube Player in the Email

The safest cross-client pattern is a clickable thumbnail, not a live YouTube iframe.

Most major email clients do not reliably support embedded video playback. Mailchimp’s own documentation therefore converts YouTube video content into a thumbnail that links to the external video page, and its current video content block explicitly recommends the same pattern.

<p>
  <a href="https://www.youtube.com/watch?v=VIDEO_ID">
    <img
      src="https://i.ytimg.com/vi/VIDEO_ID/hqdefault.jpg"
      alt="Watch: VIDEO TITLE"
      width="100%"
    />
  </a>
</p>

<p>
  <a href="https://www.youtube.com/watch?v=VIDEO_ID">
    Watch the video →
  </a>
</p>

Do not assume that every YouTube video has a working maxresdefault.jpg thumbnail. Build a fallback path or use a thumbnail resolution you know exists for the content you process.

10. Deduplication, Filters and Multi-Publication Routing

Use a Data Store when reliability matters

Make’s polling triggers remember processed records, but a production content pipeline benefits from its own idempotency layer. A Make Data Store keyed by channel_id + video_id + publication_id is a simple way to guarantee that the same video does not create multiple Beehiiv posts.

Useful routing rules

• Channel rule: accept only the expected YouTube channel ID.
• Title rule: send only videos containing approved series keywords.
• Time rule: ignore old feed entries outside the desired publication window.
• Publication rule: route different content categories to different Beehiiv publications.
• Duplicate rule: stop processing if the video ID already exists in the Data Store.
• Manual-review rule: all new videos become drafts until a human approves them.

Example multi-publication router

If Shorts classification matters, don’t pretend that the simple RSS item itself gives you a guaranteed “Short” field. Use an enrichment step or a clearly defined classification rule and test it against your channel’s actual URLs.

11. Error Handling and Failure States

12. Advanced YouTube-to-Email Architectures

Use YouTube’s push-notification infrastructure

Google also documents a PubSubHubbub-based push mechanism for YouTube channel feeds. Instead of repeatedly polling, a callback server can subscribe to the channel’s Atom topic URL and receive notifications for uploads and certain metadata updates.

This is more infrastructure than a normal Make polling scenario because you need a callback endpoint that can handle the subscription handshake and notifications. For most creators, polling is simpler; for high-volume infrastructure, push notifications are the more event-driven architecture to investigate.

Add an enrichment layer

The feed should remain the trigger, not the entire data source. An enrichment step can add data you need for the newsletter but do not want to maintain manually, such as the full description, selected metadata or additional classification.

Generate an email from the video rather than merely announcing it

A simple “New video is live” email is easy to automate, but it is also easy for subscribers to ignore. A stronger workflow can generate:

• A one-sentence summary.
• Three useful takeaways.
• A linked video thumbnail.
• A “watch the full video” CTA.
• A related CreatorOpsMatrix article.
• An optional reply question to increase newsletter engagement.

Turn the workflow into a content-distribution engine

The same canonical video ID can become the routing key for multiple destinations: Beehiiv, WordPress, Notion, Slack, a CRM, analytics storage and social publishing.

That is where Make becomes more useful than a single-purpose YouTube-to-email connector: the video becomes one source event and the rest of the system becomes a set of controlled downstream branches.

13. Production Checklist

14. YouTube to Email Automation FAQ

15. Official YouTube, Beehiiv, Make & Automation References

Related CreatorOpsMatrix Guides