# Make Problems & Issues 2026 - Credits, Webhooks & Scenario Errors

Source: https://www.tryorbye.com/products/make
Last analyzed: 2026-10-21
Try or Bye score: 62/100

## Verdict: Try with caution

Make works for some teams, but users report recurring problems (score 62/100). Most reported issues: Why does Make use so many credits?; Make webhook not triggering the scenario; Make scenarios turn off automatically after errors. Not a good fit for: Developers wanting code and self-hosting; Teams needing strict data residency on their own servers. Users most often switch to Zapier, n8n, Pipedream.

## What it is

Make (make.com, formerly Integromat) is a visual automation platform where you build 'scenarios' that connect apps, APIs and AI models with routers, iterators, aggregators and error handlers on a drag-and-drop canvas. It bills per credit (formerly operations): most module actions cost 1 credit, including every polling check. It sits between Zapier (simpler, pricier) and n8n (more technical, self-hostable) and is popular with agencies, ops teams and freelancers.

## Common errors & fixes

### Make Webhook Not Triggering Scenario

A Make webhook that doesn't start the scenario usually means the scenario is off or scheduled rather than instant, the data structure is stale, or the webhook was deactivated. Turn the scenario on with 'Immediately' scheduling, re-determine the data structure and check the webhook's Logs and Queue.

1. **Turn the scenario on and run it immediately** — Open the scenario Switch the scheduling toggle ON Click the clock on the webhook trigger and choose 'Immediately as data arrives' Save the scenario
2. **Check the webhook's Logs and Queue** — Go to Webhooks in the left menu and open your webhook Open the Logs tab and look at the status code of recent requests Open the Queue tab; if items are waiting, process or delete them Look for 410 (deactivated), 400 'Queue is full' or 429 (rate limit) responses
3. **Re-determine the data structure** — Click the webhook module in the scenario Click 'Redetermine data structure' Send a fresh request from the source app Confirm the module shows 'Successfully determined', then save
4. **Test the URL independently** — Copy the webhook URL Send a test POST with Postman or curl If Make receives it, the problem is in the sending app's configuration
5. **Recreate the webhook** — Delete the webhook module from the scenario Add a new Custom webhook and create a new URL Update the URL in the sending app Check status.make.com if it still fails

Full guide: https://www.tryorbye.com/products/make/issues/webhook-not-triggering

### Make Webhook 'Queue Is Full' or 410 Gone Error

Make returns 400 'Queue is full' when a webhook's queue hits its plan limit (667 items per 10,000 monthly credits, max 10,000) and 410 Gone when a webhook has had no scenario attached for over 5 days. Clear the queue and turn the scenario on, or reattach the webhook.

1. **Process or clear the queue** — Go to Webhooks and open the webhook Open the Queue tab Turn the scenario on so it processes the backlog, or delete stale items
2. **Process more items per run** — For a scheduled webhook, open the trigger settings Raise 'Maximum number of results' Or switch scheduling to 'Immediately'
3. **Reactivate a 410 webhook** — Attach the webhook to an active scenario Turn the scenario on If it stays inactive, create a new webhook and update the URL in the sender
4. **Raise the queue limit** — Check whether credits are exhausted under Organization > Subscription Buy extra credits or move to a higher credit tier

Full guide: https://www.tryorbye.com/products/make/issues/webhook-queue-full-410-gone

### Make Using Too Many Credits (Operations)

Make burns credits fastest through polling triggers, which cost 1 credit per check even when nothing is found, and through loops that run many modules per bundle. Switch to webhooks, poll less often and filter right after the trigger.

1. **Replace polling with instant webhooks** — Check if the app offers an instant trigger (marked 'Instant') Replace the Watch module with the instant trigger or a Custom webhook Set the scenario to run immediately
2. **Poll less often** — Click the clock icon on the trigger Change the interval from every minute to every 15-60 minutes, or to fixed times of day Raise the trigger's result limit so each run processes more items
3. **Filter right after the trigger** — Click the link between the trigger and the next module Add a filter condition so only relevant bundles continue
4. **Find the expensive scenario** — Open Organization > Credits usage (or the dashboard usage chart) Sort scenarios by consumption Open its History to see credits per run
5. **Control auto-purchase** — Go to Organization > Subscription Turn off automatic purchasing of extra credits if you prefer scenarios to pause instead

Full guide: https://www.tryorbye.com/products/make/issues/using-too-many-credits

### Make Scenario Turned Off Automatically

Make disables a scenario's schedule after errors across several consecutive runs, and immediately on fatal errors like DataSizeLimitExceededError. Outages have also auto-disabled scenarios. Find the failing module in History, fix it, then switch the scenario back on.

1. **Find the failing module** — Open the scenario and go to History Open the latest failed run Click the module with the red warning to read the error
2. **Add error handling** — Right-click the failing module and choose 'Add error handler' Use Resume or Skip (formerly Ignore) for expected failures, Break to retry later Enable 'Allow storing of incomplete executions' in scenario settings
3. **Adjust the consecutive-errors setting** — Open Scenario settings Set 'Number of consecutive errors' to a value that fits your tolerance Keep it low if failures would waste credits
4. **Check status and re-enable** — Check status.make.com for incidents Fix the cause, then turn the scenario toggle back ON

Full guide: https://www.tryorbye.com/products/make/issues/scenario-deactivated

### Make 'Invalid Refresh Token, Please Reauthorize the Connection' Error

This error (often shown as invalid_grant) means the OAuth token for Gmail, Google Drive or Microsoft 365 expired or was revoked. Reauthorize on the Connections page; if it recurs about every 7 days, your custom Google Cloud app is still in testing mode and must be published.

1. **Reauthorize and verify the connection** — Open Connections in the left menu Find the failing connection and click Reauthorize Click Verify to confirm it works Rerun the scenario
2. **Publish your Google Cloud app** — Open Google Cloud Console > APIs & Services > OAuth consent screen Change Publishing status from Testing to In production Reauthorize the connection in Make
3. **Check redirect URIs for custom OAuth clients** — In Google Cloud > Credentials, open your OAuth client Add Make's redirect URIs exactly as listed in Make's docs (some apps need both with and without a trailing slash) Save and reauthorize
4. **Create a fresh connection** — In the module, click Add next to Connection Sign in again to create a new connection If it still fails, test the new connection in a new blank scenario Open a support ticket if the error persists

Full guide: https://www.tryorbye.com/products/make/issues/invalid-refresh-token-reauthorize

### Make DataSizeLimitExceededError

DataSizeLimitExceededError is a fatal error tied to your plan's data transfer or file size limits; Make immediately disables the scenario regardless of the consecutive-errors setting. Reduce the data passed through the scenario or buy extra credits / upgrade.

1. **Check usage** — Open Organization > Subscription / usage Check data transfer against the plan allowance
2. **Move less data** — Pass file URLs instead of downloading file contents Filter out unneeded bundles early Avoid downloading large attachments you don't use
3. **Buy credits or upgrade** — Purchase extra credits (data transfer scales with credits) Or move to a plan with a higher file size limit
4. **Re-enable the scenario** — After fixing the cause, switch the scenario toggle back ON

Full guide: https://www.tryorbye.com/products/make/issues/data-size-limit-exceeded

### Make RateLimitError (429 Too Many Requests)

RateLimitError is the HTTP 429 response from the connected app (or from Make's own webhook limit of 300 requests per 10 seconds). The app's limit is shared across all your scenarios, so slow the scenario down with sequential processing, sleeps or batching.

1. **Process data sequentially** — Open Scenario settings Enable 'Sequential processing' so runs don't execute in parallel
2. **Add delays between calls** — Check the app's documented rate limit Add the Tools > Sleep module before the rate-limited module Set the delay to stay under the limit
3. **Retry with a Break error handler** — Right-click the module and add an error handler Choose Break with automatic retries Enable storing of incomplete executions
4. **Batch requests** — Use the app's bulk or batch module where available Use an aggregator to combine items into fewer calls

Full guide: https://www.tryorbye.com/products/make/issues/rate-limit-error-429

### Make ExecutionInterruptedError (Scenario Timeout)

ExecutionInterruptedError means the run exceeded Make's maximum execution time: 40 minutes on paid plans, 5 minutes on Free. Remaining bundles aren't processed. Split the job into smaller chained scenarios and lower search limits.

1. **Split into chained scenarios** — Move the second half of the work into a new scenario with a Custom webhook trigger From the first scenario, send items to that webhook with the HTTP module Each scenario then gets its own time limit
2. **Lower the per-run limit** — Open the trigger or search module Reduce 'Limit' / 'Maximum number of results' Run the scenario more often to cover the volume
3. **Store incomplete executions** — Open Scenario settings Enable 'Allow storing of incomplete executions' to review and resume interrupted runs (behavior on Free may differ)
4. **Batch API calls** — Use bulk modules or aggregators to reduce the number of calls per run

Full guide: https://www.tryorbye.com/products/make/issues/execution-interrupted-error

### Make Google Sheets Watch New Rows Not Working

Watch New Rows is a polling trigger that tracks row positions, not content. It skips rows added after a blank row, ignores rows re-added where rows were deleted, and won't fire if the scenario only runs on demand. Reset the starting point or use Search Rows with a status column.

1. **Remove blank rows and schedule the scenario** — Make sure new rows are appended directly below the last data row Set the scenario schedule to run at a regular interval (e.g. every 15 minutes)
2. **Reset where the trigger starts** — Right-click the Watch New Rows module and choose 'Choose where to start' Select 'From now on' or pick a specific row/run Save and run
3. **Replace the trigger module** — Delete Watch New Rows and add it again to reset its internal row pointer
4. **Use Search Rows with a status column** — Add a 'Processed' column to the sheet Use Search Rows filtered on Processed is empty After processing, update the row to mark it done

Full guide: https://www.tryorbye.com/products/make/issues/google-sheets-watch-new-rows-not-working

### Make BundleValidationError: Missing Value of Required Parameter

BundleValidationError means a module received a bundle with an empty required field or the wrong data type, usually because an earlier search returned nothing. Add a filter before the module, use ifempty(), or add a Skip error handler.

1. **Filter before the failing module** — Click the link before the module Add a filter: the required field 'Exists' / is not empty
2. **Provide fallbacks** — In the mapping, wrap the value with ifempty(value; default) Or use if() to choose a value conditionally
3. **Check upstream output** — Open the run in History Inspect the output bundle of the previous search module Fix the search criteria if it returns no bundles
4. **Skip expected failures** — Right-click the module > Add error handler Choose Skip (formerly Ignore) or Resume with default values

Full guide: https://www.tryorbye.com/products/make/issues/bundle-validation-error

### Is Make Down? Scenarios Not Running

If many scenarios stop at once, check status.make.com. Recent incidents (Sept 2025, Dec 2025, March, July, Aug and Oct 2026) stopped executions, left webhooks unprocessed and auto-disabled scenarios that had to be re-enabled.

1. **Check Make's status page** — Open status.make.com Find your region (shown in your Make URL, e.g. eu2.make.com) Subscribe to updates
2. **Re-enable disabled scenarios** — After the incident, open the Scenarios list Filter by inactive scenarios Switch affected scenarios back ON
3. **Replay missed webhook data** — Check the webhook's Logs for requests received during the outage Ask the sending app to resend events, or rerun with incomplete executions

Full guide: https://www.tryorbye.com/products/make/issues/make-down-scenarios-not-running

## Common problems

- **Why does Make use so many credits?** (pricing): Every module action costs a credit, and polling triggers (Watch modules) spend a credit on every check even when nothing new is found. A trigger polling every minute burns roughly 44,000 credits a month on its own, and loops through iterators multiply usage per bundle.
- **Make webhook not triggering the scenario** (reliability): One of the most common community threads: webhooks that only fire on 'Run once', stop working after weeks, or never receive data from the sender. Causes range from the scenario being off or scheduled instead of instant, to wrong data structure, to webhooks auto-deactivated after 5 days unused.
- **Make scenarios turn off automatically after errors** (reliability): Make disables a scenario's schedule after several consecutive errors and immediately on fatal errors like data size limits. This protects credits but means automations silently stop until someone notices and re-enables them.
- **Make connections keep expiring (invalid refresh token)** (integrations): Gmail, Google Drive and Microsoft 365 connections regularly fail with 'invalid_grant' or 'Invalid refresh token, please reauthorize'. Some users hit it weekly because their Google Cloud app is in testing mode, and in some threads reauthorizing doesn't fix it.
- **Make switched from operations to credits (AI modules cost more)** (pricing): On August 27, 2025 Make replaced operations with credits as its billing unit. Standard actions still cost 1 credit, but features using Make's built-in AI provider are billed by actual usage and can consume several credits per run, so AI-heavy scenarios got more expensive.
- **Make support is slow and billing refunds are hard** (support): Trustpilot reviewers describe weeks without replies and refunds only after pushing, including a case of credits charged multiple times due to platform lag. Community users note the support ticket form is the only direct contact channel.
- **Make outages disabled scenarios and dropped webhooks** (reliability): Incidents in Sept 2025 (all scenarios, ~2 hours), Dec 2025 (Cloudflare), March 2026 (US2 webhooks), July 2026 (~250 scenarios disabled for about 29 hours) and Oct 2026 (Scenario app failures) left automations stopped or webhooks unprocessed, often requiring manual re-enabling.
- **Make has a steep learning curve (bundles, iterators, aggregators)** (onboarding): Reviewers consistently say Make takes days to weeks before building complex scenarios comfortably. Concepts like bundles, iterators, aggregators, mapping and filters confuse non-technical users who expected Zapier-level simplicity.
- **Make extra credits now cost 25% more, Core capped at 300k credits** (pricing): From November 6, 2025 extra credits cost 25% more than plan credits whether bought manually (previously no premium) or via auto-purchase (previously 30%). Core was capped at 300,000 credits per month, pushing heavier users to Pro.
- **Make errors are hard to diagnose** (usability): Capterra reviewers report that errors are hard to trace and fix, and community threads show generic messages like BundleValidationError usually point to an empty value from an upstream module rather than the module that failed.
- **Make scenarios time out after 40 minutes** (performance): Paid plans stop a run after 40 minutes (5 minutes on Free) with ExecutionInterruptedError, leaving remaining bundles unprocessed. Large syncs must be split into chained scenarios or batched.
- **Make hits rate limits (429) on busy scenarios** (performance): Instant triggers and bulk processing frequently hit third-party API limits (Webflow, Google Drive), and the app's limit is shared across all your scenarios. Make itself also caps incoming webhooks at 300 requests per 10 seconds.
- **Make editor is slow with large scenarios** (performance): Reviewers mention UI sluggishness, lag and occasional freezes when scenarios grow to many modules.

## What users like

- **Far cheaper than Zapier for multi-step workflows**: 10,000 credits start at $9/month (annual), which buys much more automation than an equivalent Zapier plan for multi-step scenarios.
- **Powerful visual scenario builder**: Routers, iterators, aggregators and filters on a visual canvas handle branching and bulk data that linear tools can't.
- **Large app library plus HTTP module**: Thousands of prebuilt app modules and a generic HTTP/webhook module cover almost any API without code.
- **Built-in error handlers that don't cost credits**: Error handler routes (Resume, Skip, Break, Rollback) and routers don't consume credits, and incomplete executions can be stored and retried.
- **Usable free plan for testing**: The Free plan includes 1,000 credits a month and 2 active scenarios, enough to learn the tool and run light automations.

## Pricing

- **Free**: $0 (free)
- **Core**: $10.59 (monthly) — hidden costs: Extra credits cost 25% more than plan credits; auto-purchase buys 10,000-credit packs when you run out; polling triggers use credits on every check.
- **Pro**: $18.82 (monthly) — hidden costs: Extra credits cost 25% more than plan credits; AI-provider modules can use more than 1 credit per run.
- **Teams**: $34.12 (monthly) — hidden costs: Extra credits cost 25% more than plan credits.
- **Enterprise**: yearly

## Who should and shouldn't use it

- **Automation agencies and freelancers** — Good fit: Visual builder and low per-credit cost suit building many client workflows.
- **Ops and marketing teams with multi-step workflows** — Good fit: Branching and bulk processing are much cheaper than on Zapier.
- **Small businesses moving off Zapier to save money** — Good fit: Same integrations for a fraction of the price, if someone can learn the builder.
- **Complete beginners wanting simple two-step zaps** — Depends: Works, but Zapier is easier to learn for simple triggers and actions.
- **High-volume polling workloads** — Depends: Every check costs a credit; switch to webhooks or costs climb quickly.
- **Developers wanting code and self-hosting** — Avoid: No self-hosting and limited custom code; n8n fits better.
- **Teams needing strict data residency on their own servers** — Avoid: Make is cloud-only.

## Alternatives

- **Zapier** (https://www.tryorbye.com/products/zapier): Easiest automation tool with the largest app library and better beginner onboarding; trade-off is a much higher price per task, especially for multi-step workflows.
- **n8n** (https://www.tryorbye.com/products/n8n): Self-host for free with unlimited executions, bills per workflow run in the cloud and allows JavaScript/Python code; trade-off is a steeper learning curve and server maintenance.
- **Pipedream**: Developer-first automation with code steps in Node.js/Python; better for API-heavy work, worse for non-coders.
- **Microsoft Power Automate**: Included with many Microsoft 365 plans and strong for Microsoft-centric workflows; clunkier outside the Microsoft ecosystem.
- **Activepieces**: Open-source, self-hostable no-code builder with a simpler UI; smaller integration library.
- **IFTTT**: Very simple consumer automations at low cost; not suitable for business workflows with branching or data processing.

## FAQ

### Is Make worth it?

Yes if you build multi-step automations and can invest a few days learning its scenario builder: 10,000 credits start at $9/month on annual billing, far cheaper than Zapier for the same workload. It is less worth it for beginners who want simple two-step automations or for high-volume polling workloads where every check costs a credit.

### Why is Make using so many credits?

Most module actions cost 1 credit, and polling (Watch) triggers cost 1 credit per check even when no new data is found. A trigger checking every minute uses about 44,000 credits a month. Switch to instant webhooks where possible, poll less often and put filters right after the trigger.

### What is the difference between operations and credits in Make?

Since August 27, 2025 Make bills in credits instead of operations. Existing balances converted 1:1 and most actions still cost 1 credit, but features using Make's built-in AI provider are billed by actual usage and can cost more. Operations are still shown in run history.

### How much does Make cost?

Free includes 1,000 credits a month. At 10,000 credits, Core is $9/month billed annually ($10.59 monthly), Pro $16 ($18.82 monthly) and Teams $29 ($34.12 monthly). Enterprise is custom. Prices rise with higher credit tiers, and extra credits cost 25% more than plan credits.

### What happens when I run out of credits in Make?

Scenarios stop running, and incoming webhook data is queued up to your queue limit. If auto-purchase is on, Make buys 10,000 extra credits at a 25% premium. Exhausting data transfer can also trigger an auto-purchase.

### Why is my Make webhook not triggering?

Check that the scenario is on and set to run immediately, that the webhook isn't deactivated (unused webhooks are disabled after 5 days and return 410), that the queue isn't full, and that the sender is posting to the right URL. Re-determining the data structure or recreating the webhook fixes many cases.

### Why did my Make scenario turn off by itself?

Make disables a scenario's schedule after several consecutive errors and immediately on fatal errors such as exceeding data limits. Platform outages have also disabled scenarios. Fix the failing module, then turn the scenario back on.

### Is Make cheaper than Zapier?

Usually yes for multi-step workflows: Make's 10,000 credits cost $9-$29/month depending on plan, while Zapier charges more per task. Make's polling triggers do spend credits on empty checks, which can narrow the gap.

### Make vs n8n: which is better?

Make is easier for non-developers and fully hosted. n8n can be self-hosted for free with unlimited executions and supports custom code, so it is cheaper at high volume for technical teams willing to maintain a server.

### Is Make the same as Integromat?

Yes. Integromat rebranded as Make in 2022, and older scenarios were migrated to the Make platform.

### Is Make hard to learn?

It has a steeper learning curve than Zapier. Reviewers say concepts like bundles, iterators, aggregators and mapping take days to weeks to master before complex scenarios feel easy.

### Can I get a refund from Make?

Make's subscriptions are generally non-refundable. Reviewers report getting refunds for billing errors only after pushing support through the ticket form, which is the only direct contact channel.

### What is the maximum execution time in Make?

40 minutes per run on paid plans and 5 minutes on Free. Longer runs end with ExecutionInterruptedError, so split big jobs into chained scenarios.

---
Try or Bye aggregates problem patterns from user reviews, forums, and app stores. Methodology: https://www.tryorbye.com/methodology