Transparency note: ✋ Hands-on marks what I personally did inside Make. 📋 Researched marks features and pricing compiled from Make’s official site and public sources. Importantly, my hands-on test did not end in a working automation — I’ll be honest about that below, because the experience itself is the most useful thing I can tell you.
This article contains affiliate links. If you buy through them I may earn a commission at no extra cost to you. All opinions are my own.
Make (formerly Integromat) is one of the most powerful visual automation platforms in 2026 — a canvas where you wire together apps and APIs into “scenarios” that run on their own. It’s frequently recommended as a cheaper, deeper alternative to other no-code automation tools. I set out to build a real automation with it, hit a wall, and then compiled the full feature and pricing picture from Make’s site. Here’s the honest result — including the part where it didn’t work for me.
Contents
✋ Hands-On: This Time I Actually Built and Ran a Working Flow
Update (July 2026): Last time I tried to build a complex “HTTP → OpenAI → WordPress” flow from scratch and couldn’t get it running end to end. This time I narrowed the goal to a flow that actually runs on the free plan and touches no live production data — and I built it, hit Run, and got real results.
What I actually built: “HTTP request (fetch a public API’s JSON) → Set variable (turn the returned data into a variable).” Free plan, signed in with Google, zero cost.
The first real gotcha (easy for beginners to hit): When adding the HTTP request module, I fumbled and picked “API key” as the Authentication type — which immediately demanded I create a credentials keychain and blocked Save with “Credentials: Value must not be empty.” A public API needs no auth at all — the right choice is “No authentication.” I got stuck here a few times before spotting it.
The real run result: After switching to no-auth, filling in a public JSON API URL, and leaving the method on GET, I hit “Run once” — and the request genuinely fired: status code 200, a returned data array, 5.1 KB transferred, 1 credit used. The execution panel lays out INPUT / OUTPUT / status code / credit usage in full, which is genuinely clear.
Adding a “process” step to make it a complete flow: I then chained a “Set variable” module after it, turning the API response into a variable (I used it to compute the length of the returned array). Hit Run again — both modules lit up green, 1 credit each, and the data genuinely flowed from step one into step two and got processed into a new value. That’s a full “fetch → process → output” flow, running start to finish.
So what about the OpenAI and WordPress steps? Honestly — I didn’t run them, and the reason may apply to you too:
- The OpenAI module needs an “OpenAI API key” — a separately paid key from the OpenAI platform, which is not the same as a ChatGPT subscription. I didn’t actually open or connect this module — I only confirmed from the app list that Make has an OpenAI app; I don’t have an API key, and wiring it up for real still requires creating a connection with an OpenAI API key. Plenty of readers also don’t have an OpenAI API key, so it’s worth knowing up front: the free plan lets you build the flow’s skeleton, but wiring in an AI step like OpenAI means going and enabling a paid OpenAI API yourself.
- I also didn’t open or run the WordPress module — because it would actually publish to your live site, and I didn’t want to post a test article to a production site just to demo it, so I skipped it this time.
What it actually feels like to use (my take): The canvas looks approachable, but the real work is in the details — every module needs field-by-field configuration, picking the wrong auth type stalls you (as it did me), and data has to be mapped by hand between steps. It genuinely can chain APIs, AI, and app actions into a powerful flow; the ceiling is high. But with zero automation background, expecting to self-build a complex flow on a blank canvas will be frustrating. My advice: start with a simple 2-3 module flow (like my fetch + process one), run it once to get the feel, then chain up to something bigger — or start from a template. The free plan (1,000 credits/month, 2 active scenarios) is plenty for practice.
Everything below — the full feature list, pricing, and the Zapier comparison — is organized research, not step-by-step hands-on, and I mark it clearly. The flow above is the part I actually built and ran this time.
📋 What Make Does (Features)
Compiled from make.com, 2026-06. Make is a visual automation builder — you assemble “scenarios” from modules instead of writing code:
- Visual scenario builder — a drag-and-connect canvas (the one in my screenshot) where each module is a step.
- 2,000+ app integrations plus generic HTTP/JSON modules to call almost any API (the HTTP step I used).
- Flow control — Router (conditional branches), Iterator (loop over arrays), and Aggregator (combine many items into one) for non-trivial logic.
- Error handling — dedicated error routes with Resume / Rollback / Commit, so a failed step can fall back instead of silently breaking.
- Scheduling & webhooks — run on a schedule or trigger instantly from an incoming webhook.
- AI modules — built-in OpenAI and other AI steps (the OpenAI image step in my attempt), plus newer AI-agent features.
The takeaway from researching it alongside my hands-on attempt: the feature depth is exactly why it’s powerful and why it’s hard for a beginner to self-build — those flow-control and error modules are capability, but also complexity.
📋 What people build with Make
Compiled from make.com use cases — examples of what the platform is built for (not things I completed myself):
- Lead & CRM sync — push form submissions or ad leads into a CRM, spreadsheet, and notification channel automatically.
- E-commerce order flows — on a new order, update inventory, notify fulfillment, and trigger follow-up emails.
- Content pipelines — generate or transform content with AI, then post it to a CMS like WordPress (the category my own attempt fell into).
- Cross-app data sync — keep records consistent across multiple SaaS tools without manual copying.
- Internal notifications & reporting — scheduled pulls that summarize data and post it to Slack or email.
These are the kinds of high-value, repeatable flows Make is designed for — and also why teams that get over the learning curve tend to stick with it.
📋 Make Pricing in 2026
Based on 10,000 credits/month; cost scales with usage; check make.com for current pricing. Make bills by “credits” (operations) — higher usage means a higher tier:
- Free — $0. A limited number of operations to try the builder — enough to experiment (it’s the tier I attempted on).
- Core — $10.59/month, or $9/month billed annually. For individuals running real personal automations.
- Pro — $18.82/month, or $16/month billed annually. More operations and advanced features for heavier use.
- Teams — $34.12/month, or $29/month billed annually. Collaboration and shared scenarios for groups.
- Enterprise — custom. Advanced security, support, and scale.
All figures are based on 10,000 credits/month; your cost scales with usage, and annual billing saves roughly 15%+. Always check make.com for current pricing.
📋 Make vs Zapier (Objective — Not Personally Compared)
I did not personally test Zapier, so this is objective, third-party positioning only — not a hands-on comparison. Per public information: Zapier is generally considered the easier, more beginner-friendly platform with the largest app catalog and a gentler learning curve, while Make is usually described as more powerful and more cost-efficient at scale, with deeper data handling (routers, iterators, aggregators) and operations-based pricing that tends to be cheaper for high-volume, complex flows. The common summary is “Zapier for simplicity, Make for depth and value.” My own attempt is consistent with the “depth = steeper curve” half of that — but I can’t vouch for the Zapier side because I haven’t used it.
Pros & Cons
Pros
- Genuinely powerful — ✋ even in a failed attempt, the canvas clearly chains real APIs, AI, files, and app actions.
- Deep flow control & error handling — 📋 routers, iterators, aggregators, and dedicated error routes.
- Cost-efficient at scale — 📋 operations-based pricing is generally cheaper than per-task rivals for high-volume flows.
- A real free tier to experiment — ✋ I could try building without paying.
Cons
- Steep for beginners building from scratch — ✋ I attempted a multi-step scenario and couldn’t get it working end-to-end without an automation background.
- Not “template-and-go” when you self-build — ✋ a blank canvas asks a lot before anything runs.
- Credit/operations model needs watching — 📋 cost scales with usage, so complex high-frequency flows can climb.
- Power = complexity — 📋 the same flow-control depth that makes it strong is what makes it hard to learn.
Who Make Is For (and Who Should Be Careful)
A good fit if you’re technically comfortable — a developer, ops person, or someone who enjoys wiring systems together — or a team that needs deep, cost-efficient automation and is willing to invest in the learning curve (or start from templates).
- Technical users / developers who want HTTP/JSON control and complex branching.
- Teams automating high-volume, multi-step processes where operations-based pricing pays off.
- People willing to start from a template rather than a blank canvas.
Be careful if you’re a non-technical beginner expecting to self-build a complex flow with no prior automation experience — ✋ that’s exactly where I struggled. You may finish faster with a ready-made template, or with a simpler tool, and grow into Make later.
Frequently Asked Questions
Is Make hard to learn?
✋ In my experience, yes — building a multi-step scenario from scratch without an automation background was hard enough that I didn’t get my flow working end-to-end. The power comes with a real learning curve.
Did you get your Make automation working?
✋ No — honestly, I attempted an HTTP → OpenAI → download → WordPress scenario but could not complete a working version. I’m sharing the attempt because the difficulty is the useful lesson.
How much does Make cost?
📋 Based on 10,000 credits/month: Free $0, Core $10.59/mo ($9 annual), Pro $18.82/mo ($16 annual), Teams $34.12/mo ($29 annual), Enterprise custom. Cost scales with usage — check make.com for current pricing.
Is Make better than Zapier?
📋 I did not personally compare them. Objectively, Zapier is usually seen as easier with more apps, while Make is seen as more powerful and cheaper at scale. Pick by whether you value simplicity or depth.
Does Make have templates?
📋 Yes — Make offers pre-built templates, and based on my hands-on struggle, starting from a template is the approach I’d suggest over a blank canvas if you’re new.
Can Make use AI / OpenAI?
📋 Yes — it has built-in AI modules; my attempt included an OpenAI image-generation step. I just didn’t complete the surrounding flow.
Is the free plan enough to try Make?
✋ It was enough to attempt building a scenario without paying — but “enough to try” isn’t the same as “enough to succeed,” as my unfinished flow shows.
What is a “credit” or operation in Make?
📋 Make bills by operations/credits — roughly each module run consumes one. Pricing tiers are sized by monthly credits (the figures above assume 10,000/month), so heavier flows cost more.
Is Make really “no-code”?
It’s marketed as no-code/low-code, and you don’t write traditional code. But ✋ in my hands-on attempt it felt closer to low-code for anything non-trivial — you still reason about data structures, mapping, and API behavior, which is why a complex from-scratch build defeated me without an automation background.
What happens when a Make scenario fails?
📋 Make has error handling — you can attach dedicated error routes with options like Resume, Rollback, and Commit so a failed step falls back gracefully instead of breaking silently. I didn’t get far enough to configure this myself; it’s from the docs.
The Verdict
Make is a genuinely powerful automation platform — ✋ even my failed attempt made its depth obvious. But I have to be honest about the experience that matters most: I tried to build a real HTTP → OpenAI → WordPress workflow from scratch and couldn’t get it working, because without an automation background the learning curve is steep and this is not a plug-in-a-template-and-go tool when you self-build. If you’re technical, or a team ready to invest in learning (or to start from templates), Make’s power and scale-friendly pricing are compelling. If you’re a non-technical beginner, go in with realistic expectations — start from a template, and don’t assume a blank canvas will “just work.”
If you want to try it yourself, you can start with Make’s free plan ↗ — just know the learning curve is real.