WordPress Forms to Google Sheets Without Make
Skip the monthly Make subscription and per-operation fees. Connect WordPress forms directly to Google Sheets with a one-time purchase.
TL;DR
SheetLinkWP replaces Make (formerly Integromat) for the WordPress form → Google Sheets workflow. Direct webhook connection, no per-operation fees, supports all 12 major form plugins. One-time $39 vs Make's $200+/year.
Make (formerly Integromat) is the most technically sophisticated of the mainstream automation platforms. Its visual scenario builder is genuinely best-in-class - routers, iterators, aggregators, filters, and error handlers all composable in a clean canvas. For complex multi-app workflows, Make is a joy to use.
It's also cheaper than Zapier. Make's Core plan at $10.59/month for 10,000 operations is roughly one-third the cost of Zapier's equivalent tier. For high-volume workflows, those savings add up.
But here's the thing: if the only scenario you have is "WordPress form submission -> Google Sheet row," you're still paying for a whole automation platform. A two-module scenario is the simplest thing Make can do, and you're paying $127/year for it (Make Core $10.59/mo). Compound that over a few years and you're in the hundreds of dollars for what should be a solved, one-time purchase.
SheetLinkWP is that one-time purchase. It's a WordPress plugin that connects your forms directly to Google Sheets via Apps Script webhook - no Make, no operations to count, no scenarios to maintain. This guide walks through the replacement, shows the real cost math over 3 years, and explains the narrow cases where keeping Make for the form-to-Sheet workflow still makes sense (spoiler: they're rare).
Where Make Shines and Where It's Overkill
Make earns its reputation on complex, multi-step scenarios. If your workflow looks like form submission -> enrich via Clearbit -> create HubSpot contact -> send personalized Mailchimp email -> notify Slack -> create Trello card, Make's visual scenario builder is genuinely the right tool. Routers, iterators, error handlers, and 1,800+ app modules make it a joy to work with for that kind of orchestration.
Where Make is overkill: single-destination workflows. If your scenario is literally two modules - a WordPress webhook trigger and a Google Sheets add-row action - you're paying $127/year for an automation platform to do what a $39 plugin does permanently. Worse, every submission counts as one operation against your Core plan's 10,000/month quota. Heavy traffic months will push you toward higher tiers.
Data path is the other consideration. Make routes your submissions through its servers (EU or US hosted, depending on your region). That's an additional data processor in your compliance footprint - relevant for GDPR, HIPAA, and some enterprise procurement reviews.
SheetLinkWP targets exactly the overkill case: direct WordPress-to-Sheets delivery, one-time price, no operations quota, data goes direct to Google without Make's servers in the middle. You can keep Make for your genuinely multi-app scenarios and save operations budget for the flows that actually need it.
Direct Delivery vs Make's Operation Model
Make charges per operation - each module run in a scenario consumes 1 operation. For a 2-module form-to-Sheet scenario, every submission costs 2 operations. That's the model SheetLinkWP eliminates.
- Make: WordPress webhook trigger (1 operation): Your form plugin posts to a Make webhook URL. Make receives and queues the payload. One operation counted.
- Make: Google Sheets add-row module (1 operation): The scenario's second module maps the webhook data to Sheet columns and makes a Google Sheets API call. Second operation counted.
- Make: 10,000/month quota on Core: At 2 operations per submission, the 10,000 quota supports up to 5,000 submissions/month. Higher traffic needs the Pro plan at $18.82/month for 10,000 ops (adjusted) or Teams at $34.12/month for 40,000 ops.
- SheetLinkWP: submission captured directly: The plugin hooks into your form plugin's native submission action. No webhook endpoint on a third-party service, no operations counted, no quota.
- SheetLinkWP: direct POST to Apps Script: Data flows from WordPress straight to your Apps Script endpoint in Google. Typically 300-700ms round trip. No Make servers in the path.
- SheetLinkWP: no quota at any volume: 100 submissions/month or 100,000 - same flat price. No scaling penalty, no tier upgrades triggered by traffic growth.
What You Need
- A WordPress site with any supported form plugin
- A Google account with access to Google Sheets
- SheetLink Forms plugin
Step-by-Step Setup
- 1
Create a Google Sheet
Open Google Sheets and create a blank spreadsheet for your form data.
- 2
Deploy the Apps Script webhook
In your Sheet, go to Extensions > Apps Script, paste the SheetLinkWP receiver script, deploy as a Web app, and copy the URL.
- 3
Install SheetLink Forms
Download from sheetlinkwp.com or WordPress.org. Upload and activate.
- 4
Connect and configure
Paste the webhook URL in SheetLink > Settings. Go to Field Mapping, select your form plugin, choose your form, and map fields to Sheet columns.
- 5
Test the connection
Submit a test entry. Verify the row appears in Google Sheets within seconds.
Real-World Use Cases
Simple form-to-Sheet scenario - replace the cheapest use case first
You have one Make scenario: WordPress webhook -> Google Sheets add row. It uses 2 operations per submission. At 1,000 submissions/month, that's 2,000 operations - still within Make Core's 10,000 quota, but eating 20% of it. SheetLinkWP frees up that quota for more valuable Make scenarios (CRM sync, email automation, etc.).
Multiple forms each with their own Make scenario
Agency site with 5 separate contact/quote/newsletter/job-application/event-signup forms. Each has its own Make scenario (5 scenarios total), each running 2 modules per submission. 500 combined submissions/month = 1,000 operations. More importantly, 5 scenarios to maintain. SheetLinkWP handles all 5 forms with one mapping config, conditional routing for Sheet destination.
EU-based business with data residency concerns
A European small business is sensitive to US-based cloud services in their data pipeline. Make is based in Czech Republic (EU), but their infrastructure still involves multiple regions. SheetLinkWP's direct WordPress -> Google path removes Make's servers from the flow entirely, simplifying the compliance footprint.
Growing lead gen site approaching Make's operation tier
You're on Make Core at 10,000 ops/month. Your form submission volume is growing - you just hit 4,500 submissions/month (9,000 ops on your 2-module Sheet scenario alone). You're about to need Pro at $18.82/month just for this one use case. SheetLinkWP eliminates the pressure entirely.
Advanced Tips
Keep Make for the scenarios where it shines
Don't cancel Make. Its scenario builder is best-in-class for complex flows. Replace only the simple 2-module WordPress -> Sheets scenarios with SheetLinkWP. You'll free up operations budget for the multi-app scenarios Make was actually designed for.
Scenario count matters as much as operation count
Make Free limits you to 2 scenarios. If you've been bottlenecked by that limit, SheetLinkWP frees up your scenario slots by handling form-to-Sheets entirely outside Make. Suddenly you have 2 scenarios available for the workflows that actually need automation platform features.
Make's routers can be replaced with SheetLinkWP conditional routing
If your Make scenario uses a router to send different form submissions to different Sheets or tabs, SheetLinkWP's built-in conditional routing does the same - inside the WordPress admin, no operations consumed. Route by form ID, field value, UTM source, or submitter role.
Dual-write during migration
Activate SheetLinkWP alongside your existing Make scenario for 2-4 weeks. Point them at different tabs of the same Sheet. Compare row counts and data quality. When SheetLinkWP proves stable, pause the Make scenario. You'll see the operations quota drop immediately.
3-year cost math for finance approval
Make Core $381 (3 years, Sheets-only scenarios) vs SheetLinkWP $39 one-time. Even adding optional SheetLinkWP add-ons like Multi-Node Routing ($19/mo = $684 over 3 years), you break even at tier parity. For pure form-to-Sheets, SheetLinkWP is 10x cheaper over 3 years.
Troubleshooting
Coming from Make - how do I recreate my scenario?
Make scenarios for form->Sheets typically have 3 modules: a WordPress webhook trigger, a data transformer, and a Google Sheets row creator. SheetLinkWP replaces all three with a single plugin. Install it, paste the webhook, map fields, done.
I was using Make's router for conditional logic
SheetLinkWP has built-in conditional routing. You can route submissions to different Sheets or tabs based on form ID or field values - directly in the plugin settings.
My Make scenario had an iterator - can SheetLinkWP replicate it?
For form-to-Sheets specifically, iterators are rarely needed - you're usually creating one row per submission. For repeater field handling (Formidable, Fluent Pro), SheetLinkWP's "Expand repeaters to rows" mode writes one row per repeater item. For more complex iteration (processing an array of items and running a second API call per item), that's a case where keeping Make makes sense.
I need Make's data transformer functions (like text.upper() or date.format())
For basic transformations, use Google Sheets formulas in the destination cells (UPPER, LOWER, TEXT, etc.). For more complex transformations, run the raw data into SheetLinkWP, then use a helper Sheet or Apps Script trigger to run the transformation. For truly complex multi-field transforms, keep that specific step in Make.
Make vs SheetLinkWP for WordPress Forms
| Feature | Make (Free) | Make (Core) | SheetLinkWP | |
|---|---|---|---|---|
| Monthly cost | $0 | $10.59/mo | $0 (one-time $39) | |
| Operations/month | 1,000 | 10,000 | Unlimited | |
| Cost per extra operation | Upgrade required | $0.001+ | N/A - no limits | |
| Scenarios (workflows) | 2 | Unlimited | N/A - built-in | |
| Data passes through | Make servers | Make servers | Direct to Google | |
| Setup per form plugin | Separate scenario | Separate scenario | One plugin | |
| UTM capture | Manual module | Manual module | Automatic | |
| WordPress plugin required | Make webhook | Make webhook | SheetLink Forms |
Frequently Asked Questions
Is Make better than SheetLinkWP for form-to-Sheets?
Make is a general-purpose automation platform - great for complex multi-step workflows. But for the specific task of sending WordPress form data to Google Sheets, SheetLinkWP is simpler, cheaper, and more reliable (direct connection, no middleware).
Should I keep Make for other automations?
Yes. If you use Make for workflows beyond form->Sheets (like sending emails, updating CRMs, triggering other apps), keep Make for those. Just move your form->Sheets scenario to SheetLinkWP to save operations and simplify that specific workflow.
Does SheetLinkWP have the same routing capabilities as Make?
For form-to-Sheets routing, yes. SheetLinkWP can route different forms or field values to different Sheets/tabs - which covers the most common Make router use case for this workflow.
What about Make's error handling?
SheetLinkWP has a built-in retry queue with exponential backoff. Failed deliveries are cached and retried automatically. This is comparable to Make's error handling for simple form-to-Sheets workflows.
Does SheetLinkWP count operations the way Make does?
No. There is no operations quota. You pay a flat $39 one-time for the plugin and handle any volume - 100 submissions/month or 100,000. No per-submission fees, no tier upgrades triggered by growth.
What Make features are not replicable in SheetLinkWP?
Make's visual scenario builder, its 1,800+ app ecosystem, its iterators/aggregators/array operators, and its complex branching logic with multiple routers. SheetLinkWP is purpose-built for WordPress form -> Google Sheet; for broader orchestration, Make remains the right tool.
How do I decide which Make scenarios to keep vs replace?
Look at each scenario's module count. 2-module scenarios (trigger + single action) are almost always cheaper to replace with a purpose-built tool like SheetLinkWP. 3+ module scenarios with transformations, routers, or multi-app flows are where Make earns its subscription fee - keep those.
What about scenarios that include WordPress form, Sheet, AND Slack?
A common pattern. You can either: (1) Let SheetLinkWP write to Sheets and have Make watch the Sheet for new rows to trigger Slack, or (2) Use SheetLinkWP's Fan-Out add-on ($19/mo) which delivers to Sheets + Slack + email + webhooks simultaneously without Make. Option 2 removes Make from this flow entirely if the Sheet and Slack delivery are the only two destinations.
Related How-To Guides
Replace Your Make Scenario - Direct Form-to-Sheets Connection
One plugin, one-time $39. No operations to count, no scenarios to maintain.