Automation to Newsletter: Where Five Catalogues Stop

You want the signup to land in your newsletter tool, and your automation handles that in one module. Then you want the next step: the issue itself written, scheduled, sent. That is where the catalogue runs out.

We opened the app directories of all five automation tools we cover for two destinations, beehiiv and systeme.io, and then read what the two platforms publish about their own API and MCP access. Ten directory pages, then both vendors’ developer documentation and help centres. The shape that came out is the same on every tool, and the clearest difference we could confirm between the two platforms is not a feature at all — it is how much of the boundary each one prints.

Quick Answer

None of the five tools can create or send a newsletter through a dedicated module. Zapier, Make, Pabbly Connect and Latenode all stop at subscribers, tags and reads; n8n has no connector for either platform at all. On beehiiv, two of them can list posts and three can delete one — but nothing in any of the ten pages creates one.

The one route a connector still has is the generic custom API call module, and even that is uneven: Make ships one for both platforms, Pabbly lists one in its directory rather than among its internal apps, and Zapier offers one for beehiiv but not for systeme.io – though Zapier also has a platform-level webhook app, on paid plans only, that reaches either.

Go through the API and the two platforms document themselves differently in one respect that matters before you build anything. beehiiv prints where its plan line falls, twice: the Create post endpoint says it is available to publications on the Pro and Enterprise plans, and the MCP plan table draws the same line for scheduling and sending. On systeme.io we found no plan requirement in the API reference index, and none on the send endpoint’s own reference page either.

What the Newsletter Step Means Here

Two different jobs get called the same thing, and the catalogues treat them nothing alike.

The list job      a form, a checkout or a CRM adds or updates a subscriber,
                  tags them, or moves them between segments

The issue job     something writes the post or the newsletter itself,
                  schedules it, and sends it to the list

The list job is the one the catalogues are built around. Where a connector exists at all, it does this. On beehiiv, Zapier, Make and Latenode each list a Create a Subscriber action and Pabbly lists Create Subscriber/Subscription. On systeme.io the object is a contact rather than a subscriber, and Zapier, Make, Pabbly Connect and Latenode each create or update one. The templates on the vendors’ own pages are full of this job — a Facebook lead becomes a beehiiv subscriber, a Shopify order adds a systeme.io tag. One cell is the exception, and it is the thin one everywhere: n8n, which has no connector for either platform. The issue job is the one we went looking for, and that one is absent across all ten.

The Five Catalogues, Side by Side

Each cell below was read on the vendor’s own directory page on November 5, 2026, with the filter tabs and load more controls each page offered opened to the end.

Tool	beehiiv	systeme.io	Generic API module
Zapier	61 items; posts are read and delete only	5 triggers, 6 actions, no newsletter object	beehiiv only
Make	11 triggers, 26 actions, 13 searches	18 actions, 7 searches, no triggers	Both
Pabbly Connect	6 triggers, 4 actions	8 triggers, 20 actions	Built-in API app
n8n	No result in the directory	No result in the directory	HTTP Request node
Latenode	9 actions, no trigger	1 trigger, 9 contact actions	Not listed on either page

The counts differ by an order of magnitude and the answer does not. Twenty-six actions on Make’s beehiiv app and four on Pabbly’s get you to the same place on the issue job.

Zapier: Posts You Can Read, and One You Can Delete

Zapier’s beehiiv app is the largest of the ten we opened. Counted from the page itself, it runs to 61 triggers, actions and searches. Six of them name a post: the trigger New Post Sent, and the actions List All Posts, View a Post, View Aggregate Post Stats, List All Post Templates and Delete a Post.

That is the whole set. You can be told when a post has gone out, enumerate posts, read one, pull aggregate stats, and destroy one. There is no create, no schedule and no send.

Zapier’s systeme.io app is a different size and the same answer. Five triggers — New Completed Campaign, New Optin, New Sale, New Webinar Registration and New Tag Added to Contact, every one of them instant — and six actions: create or update a contact including tags, remove a tag, subscribe to a campaign, create or update a contact and grant course access, revoke course access, unsubscribe from a campaign. A newsletter is not an object this connector knows about, on either side of that split.

Make: A Vendor-Maintained beehiiv App, and a systeme.io App That Cannot Start

Make’s beehiiv page carries a Verified badge and the line “This app is supported and maintained by the official vendor beehiiv”. Make is the only one of the five platforms that names a maintainer at all: the Zapier, Pabbly and Latenode pages for both vendors carry none of the words maintained, official vendor or Verified, and n8n publishes no page for either vendor to carry one. Make’s own glossary separates the two things the badge could mean – Verified Apps are “reviewed and maintained by our team”, Community Apps are “built and maintained by the community” – so the badge marks Make’s review and the line underneath it names who does the work. Those two lines differ across Make’s own pages: its systeme.io app carries the same Verified badge but names a third-party developer, Integration At Scale. The module list reads All 50, split 11 triggers, 26 actions and 13 searches. The post modules are Delete a Post and View a Post, plus View an Email Blast.

Make’s systeme.io app has a structural limit worth knowing before you plan around it. The filter row reads All 25, Actions 18, Search 7 — and there is no Triggers tab. systeme.io can be the destination of a Make scenario. It cannot be the thing that starts one.

The 18 actions are contacts, contact fields, tags, memberships and enrollments. No newsletter, no campaign, no email.

Pabbly Connect: The Post Is a Trigger, Never a Destination

Pabbly’s beehiiv page is explicit about the asymmetry, and you can read it off the two column headings. Under When this happens, six trigger events, the first of them Post Sent. Under Do this, four action events: add a subscription tag, create a subscriber, get a subscription by email, update a subscription.

A published post can start a Pabbly workflow. Nothing in the action column goes the other way.

Pabbly’s systeme.io page is the larger of the two, with eight triggers and twenty actions, and it reaches further into the product than any other connector on this page — contacts, tags, courses, memberships, communities, enrollments. It still does not reach a newsletter.

n8n: Nothing in the Directory for Either

n8n’s integrations directory listed 2,622 apps on the day we read it. Searching it for beehiiv returns “0 integrations” and the end-of-results message. So does systeme, and so does systeme.io.

We ran the same search for mailchimp as a control and got two results, so the search itself works and the zero is a zero.

Two things sit outside that directory and should not be read into the zero: community nodes, which n8n distributes separately, and the HTTP Request node, which n8n lists under All integrations (nodes) on its Starter, Pro and Enterprise plans and which talks to any API. What the zero means precisely is that n8n ships no official node for either platform.

Latenode: Nine Actions and No Trigger

Latenode’s beehiiv page hides most of its list behind a Show all 9 actions control. Expanded, it is Create Subscriber, Delete Subscriber, Delete Segment, Delete Post, List All Posts, List All Email Blasts, List All Publications, List All Segments and List All Subscribers. The page has no trigger section at all, so beehiiv cannot start a Latenode scenario.

The systeme.io page lists one trigger, New Events, and nine actions behind a Show all 9 actions control: Create Contact, Create Contact Field, Delete Contact, Delete Contact Field, Get Contact, List Contact Fields, List Contacts, Update Contact and Update Contact Field. Every one of them is a contact. None is a newsletter. On November 5 the action list did not render for us and only the trigger appeared; it rendered in full on November 6, which makes the earlier gap ours rather than the page’s.

The Escape Hatch, and Where It Is Missing

Four of the five catalogues carry a module that bypasses the catalogue. Zapier calls it Make a Custom API Call, Make calls it Make an API Call, Pabbly lists API (Pabbly) in its directory under IT Operations – not among the ten internal apps whose steps it says it does not count – and n8n’s equivalent is the HTTP Request node that the directory search does not cover.

This matters for how you read everything above. “No dedicated module” is not “cannot be done”. It means the step you wanted as a drop-in becomes a request you assemble: an endpoint, an auth header, a body you build by hand, and your own handling when it fails.

One gap in the escape hatch is worth naming, along with the way around it. On Zapier, the custom API call is listed on the beehiiv app and not on the systeme.io app. The app catalogue is not the whole platform, though. Webhooks by Zapier is one of Zapier’s own platform-level apps, and its POST, PUT and Custom Request actions each take a URL and a Headers field – which is what systeme.io’s send endpoint asks for, since it authenticates with an X-API-Key header. That app is badged Premium, and Zapier’s pricing FAQ defines the term: “Premium apps are select apps exclusively available to users on paid Zapier plans.” So the gap is not that Zapier cannot reach systeme.io. It is that reaching it costs a paid Zapier plan and leaves the catalogue behind.

beehiiv Prints the Line Twice

Take the API route to beehiiv and the plan requirement is printed on the write endpoints themselves. The Create post reference reads “This endpoint is available to publications on the Pro and Enterprise plans.”, and Update post carries the same sentence. The list, get, delete, test-send, preview and aggregate-stats references print no plan line at all.

beehiiv’s MCP server — the surface an AI client connects to — draws the line in the same place. The MCP help article says connecting needs no waitlist and no paid plan. beehiiv’s pricing page puts beehiiv MCP inside Lite’s feature list rather than Free’s, so the vendor’s two pages do not agree on whether a free account can connect at all. What the MCP can do once connected depends on the plan, and separately on the workspace role and permissions, which beehiiv says it reuses.

beehiiv plan	What the MCP can do
Free	Answer questions and review publication data, read-only
Lite	Everything on Free, plus creating, editing and managing content
Pro	Everything on Lite, plus scheduling and sending posts
Enterprise	Everything on Lite, plus scheduling and sending posts

Sending is the boundary the two surfaces share: Pro on the MCP, Pro on the endpoint. Drafting is where they part. The MCP can create and edit content from Lite upwards, while the Create post endpoint does not open until Pro, so on Lite the draft has to come through the AI client rather than the API. Activating an automation workflow stays in the app on every plan, including Enterprise.

The practical reading for anyone planning the issue job on beehiiv: Free reads, Lite drafts through the AI client, and the send starts at Pro on both of the surfaces you can drive programmatically. On Lite the post still goes out — from the beehiiv app, by hand.

systeme.io Prints the Rate, and Leaves the Line Unstated

Open systeme.io’s API reference and the Mailing section lists newsletter endpoints, including send and send-test. The index does not attach a plan requirement to any of them. The send endpoint’s own reference page reads in full, and prints no plan requirement either: it documents POST /api/mailing/newsletters/{id}/send and authenticates with an X-API-Key header.

What systeme.io does publish per plan is throughput, and it is in the pricing table. Both vendors publish one, which puts them on a single axis — though they are not metered alike: beehiiv gives each API key and each OAuth token its own allowance in fixed 60-second windows, while systeme.io applies one quota across all of an account’s keys and tokens and refills it. Whether the actions available through its API and MCP also differ by plan is not something any page we read states, in either direction.

beehiiv plan	API requests per minute	systeme.io plan	API requests per minute
Free	30	Free	30
Lite	180	Startup	60
Pro	500	Webinar	120
Enterprise	800, raisable on request	Unlimited	Unlimited

The free tier is thirty requests a minute on both. Above it the two curves separate quickly, beehiiv’s top tier is a floor rather than a ceiling — the documentation says Enterprise customers can request a higher limit — and the two are counted differently: beehiiv measures per API key and per OAuth token in fixed sixty-second windows, and notes that the first request from an idle credential is enforced at the default of 180 before your plan’s limit takes over. On systeme.io, every request made across all of your MCP keys draws on one shared quota.

One more systeme.io constraint belongs in the plan, because it decides whether an unattended build keeps running. MCP keys are valid for at most 90 days, an account can hold two at a time, and the current release does not support OAuth — the documentation lists that as planned, and says it would remove the need for key expiry.

On MCP access, the one statement systeme.io makes is on its MCP page, in a FAQ answer: the MCP server is included in all systeme.io plans, naming Free, Startup, Webinar and Unlimited. That page self-dates to April 2026, and it is a product page rather than a reference. Nothing on the pricing table contradicts it; there is no MCP row there at all.

Where systeme.io’s Own Pages Disagree

There is one question on this page we are not going to answer, because the vendor’s own documentation answers it two ways.

systeme.io’s help centre, in two articles both marked last updated October 12, 2026, says the MCP can schedule a newsletter, send a test, and “send the final newsletter directly to your audience”. The developer documentation lists the MCP’s newsletter capabilities as create, update, find and review, and adds: “At this stage, these are the only capabilities exposed by the MCP server.” That page self-dates five months old.

The newer pages are more likely to describe the product as it stands now, and the older page scopes itself with “at this stage”. That is a reasonable reading. It is not a confirmation, and this is a platform we have an affiliate relationship with, so we are leaving it as what it is: two official pages, two answers, and nothing in what we read that dates the change. If your build depends on it, the tool list your AI client shows after you connect is the thing to check.

One Catalogue Cites a Plan Name the Vendor Does Not Use

Make’s beehiiv page attaches a condition to its newsletter-list triggers: “The use of the newsletter lists feature requires a Max or Enterprise beehiiv plan.”

beehiiv’s pricing page names Free, Lite, Pro and Enterprise. There is no Max in it. We are not able to map Make’s sentence onto beehiiv’s current plans, and we would not restate it as beehiiv’s requirement. Check the requirement on beehiiv’s side before you build a scenario on those two triggers.

It is a small thing that illustrates a general one: a connector page is a third party describing someone else’s product, and it ages on its own schedule.

How We Checked This

We opened ten directory pages on November 5, 2026 — five automation tools against two destinations — plus beehiiv’s and systeme.io’s own developer documentation, help centres and pricing pages.

Every directory was read in a browser rather than fetched, because the module lists are rendered after load and hidden behind filter tabs and load more controls. On the two pages with such controls we clicked through to the end before counting. Where a page would not render a section, we have said so rather than filled the gap from an earlier reading.

This page reports documentation. We did not build any of these workflows, and nothing here is a measurement.

Verdict: Price the Issue Job Before You Pick the Tool

If the automation you want ends at the list — subscribers in, tags applied, segments kept tidy — the tool you already pay for is probably the right answer, as long as it has a connector for your platform at all. Zapier, Make and Pabbly Connect each have one for both. The connector counts in the table above matter less for that job than having an entry at all.

If the issue itself has to be automated, the catalogues are the wrong place to be looking, and the question becomes which plan you are on. On beehiiv the send is answered in writing on both programmatic surfaces, and the answer is Pro; drafting is cheaper, but through the AI client rather than the API. On systeme.io the endpoints exist and the plan requirement is not printed, which is a different situation from a free pass — it means the boundary is something you confirm in your own account rather than read off a page.

Our two platform reviews cover each one on its own terms, and the systeme.io vs beehiiv comparison covers the choice between them. What this page adds is the part neither review is about: how far the automation layer reaches in before the plan page takes over. For the pricing side of that layer, our note on how automation tools charge covers the units the five tools bill in, and the roundup of the five puts their meters side by side.

FAQ

Can Zapier send a beehiiv newsletter?

Not through a dedicated action. Zapier’s beehiiv app lists five post actions — List All Posts, View a Post, View Aggregate Post Stats, List All Post Templates and Delete a Post — and no create, schedule or send. Two routes remain, and both leave the beehiiv app’s own actions behind: the app’s Make a Custom API Call, which hands you beehiiv’s API and its plan requirements, and Webhooks by Zapier, a Premium app on paid Zapier plans that posts to any URL.

Does n8n have a beehiiv or systeme.io node?

Not an official one. Its directory of 2,622 integrations returns no result for either name, while the same search returns two results for mailchimp. Community nodes and the HTTP Request node sit outside that directory, so the zero describes n8n’s own catalogue rather than the whole platform.

Which beehiiv plan do I need to draft and to send a post?

Pro or Enterprise, on both. The Create post endpoint says it is available to publications on the Pro and Enterprise plans, and the MCP plan table puts scheduling and sending on Pro and Enterprise. The two surfaces are not equivalent below that line: on Lite the MCP can create and edit a draft that you then schedule in the app, while the Create post endpoint stays closed. On Free the MCP is read-only.

Can systeme.io start a Make scenario?

No. Make’s systeme.io app lists 18 actions and 7 searches and has no Triggers tab, so it can only be the destination of a scenario. If you need systeme.io to be the event that starts something, Pabbly Connect lists eight triggers for it and Zapier lists five.

Is the systeme.io MCP available on the free plan?

systeme.io’s MCP page says yes in a FAQ answer: the MCP server is included in all plans, naming Free, Startup, Webinar and Unlimited. That page self-dates to April 2026. Access being included is not the same as every action being available on every plan, and no page we read states the second thing either way.

How long do systeme.io MCP keys last?

Ninety days at most, with a maximum of two keys at a time. The documentation lists OAuth as planned and says it would remove the need for the expiry. For an unattended automation, that is a rotation you have to schedule.

---

Sources & Verification

All pages below were opened in a browser on November 5, 2026. The Zapier and Make catalogues for both platforms, Latenode’s systeme.io app and the two pricing pages were opened again on November 6. All ten connector pages were read once more on November 7, when the Zapier beehiiv item count was recounted from the page source and the maintainer lines were checked across all ten; the Webhooks by Zapier and Code by Zapier app pages, the Zapier pricing FAQ and the Pabbly Connect product page were added that day. Figures are reported as they read on the latest of those dates.

• Connector catalogues: Zapier beehiiv and its systeme.io app, Make beehiiv and Systeme IO, Pabbly Connect beehiiv and Systeme.io, the n8n directory and its pricing table, Latenode beehiiv and Systeme IO
• Zapier outside the catalogue: Webhooks by Zapier and Code by Zapier, read for their action lists and their badges, and the Zapier pricing page, whose FAQ defines a Premium app
• Pabbly on its own modules: the Pabbly Connect product page, read for where the API module sits in the directory and for the list of internal apps whose steps are not counted
• beehiiv: rate limiting, the Create post endpoint in the API reference, and Getting started with the beehiiv MCP, whose plan table and FAQ answers were read with each accordion opened, and the pricing page, where the plan cards and the feature list under each were read at 1,000 subscribers with yearly billing selected
• systeme.io: the pricing table, the MCP page and its FAQ, How to use the systeme.io MCP server, the help article on newsletters and campaigns, the Public API reference, and the MCP server page in the developer documentation, and the send endpoint reference

Where two of those pages disagree, both are quoted above rather than resolved.