Why Make.com File Conversion Modules Fail Above 10MB (And the Fix)

You build a Make.com scenario that converts client PDFs to Excel overnight. It runs green on the 2MB test file. Then Monday morning a 14MB invoice batch comes in, the scenario silently halts mid-run, half the rows are missing, and the client is in your Slack asking why their AR report is broken. There is no clean error — just an incomplete bundle and a burned operations budget.

This is the part Make.com's docs do not advertise: the platform's file handling has hard structural limits that punish anyone running real production volume. The good news is the failure modes are predictable, and the fix is a single HTTP module swap. Below is what actually breaks above ~10MB, why it costs you 3-5x the ops you expected, and how to replace the brittle native modules with a converter that does not care about file size.

The four failure modes nobody warns you about

Make.com's file conversion stack — the built-in PDF tools, the legacy CloudConvert connector, and most community modules — share the same architectural ceiling. Once you push past roughly 5-10MB, you hit at least one of these.

1. The 5MB HTTP body cap on inline file passing

Make.com routes binary data between modules as base64-encoded payloads inside the scenario bundle. The practical body cap for inline transfer is around 5MB of raw binary (which inflates to roughly 6.7MB encoded). Above that, the next module in the chain receives a truncated or empty data field. Worst part: the upstream module reports success because the upload to its endpoint completed — the corruption happens on the handoff back into the scenario.

2. Module timeouts on parse-heavy formats

The native PDF modules execute inside a 40-second-per-module wall. A 12MB PDF with embedded scans, complex tables, or 200+ pages routinely runs past that ceiling on the converter side. Make terminates the request, marks the operation consumed, and emits a generic RuntimeError: Module timeout that tells you nothing about which file caused it when you are batch-processing 80 documents.

3. The operations multiplier nobody priced into the quote

A single "convert PDF to Excel" step looks like one operation in the scenario builder. In practice it is three to five: download the source file, send to the converter endpoint, poll for status, fetch the result, write to storage. On the Core plan's 10,000 ops/month that is 2,000 conversions, not 10,000. Agencies running daily batches for 15 clients blow through their plan in week two and get force-upgraded to Pro at $16/month, then Teams at $29.

4. Binary corruption on chained modules

When you pipe a converted file through more than two downstream modules — say, convert -> rename -> upload to Drive -> notify Slack — the binary payload gets re-encoded at each hop. PDFs with attached fonts, signed documents, and any file with a non-trivial header (HEIC, PSD, multi-page TIFF) come out the other end either truncated or with corrupted metadata that opens in a viewer but fails programmatic parsing.

How the ops budget actually burns

Here is the math agencies miss until the second invoice from Make arrives. A real-world scenario — "watch Dropbox folder, convert PDF to Excel, write to Google Sheets, post to Slack" — looks like 4 operations. With a native conversion module it spends like this:

Step	What you see in the builder	Actual operations consumed
Dropbox watcher trigger	1 op	1 op
Download file	1 op	1 op (2 if file >5MB and chunked)
Native PDF-to-Excel module	1 op	3-4 ops (upload + poll + retry + fetch)
Write to Google Sheets	1 op	1 op per row batch
Slack notify	1 op	1 op
Total per file	5 ops	9-12 ops

Run that 500 times a month for one client and you are at 4,500-6,000 ops on a single workflow. Take on three more clients of the same size and the Core plan's 10,000-op ceiling is a memory by the 18th of the month. The fix is not a bigger Make plan — it is collapsing the conversion stack into one outbound HTTP call that costs exactly one operation, regardless of file size or processing time.

The fix: replace the native module with a single HTTP request

Make's generic HTTP module does not count polling, retries, or response payload size against your operations budget the way connector modules do. Each completed HTTP request is one operation, full stop. If you can find a conversion API that returns synchronously (no polling) and accepts files via direct multipart upload (no base64 inflation), you replace the entire flaky native chain with one stable module.

That is exactly the shape of the ConvertFleet API. One POST, one response, your converted file streams back in the body. No webhook callbacks, no job IDs to track, no inflate-then-deflate base64 dance. Business plan files have no practical size ceiling — we have processed 800MB video files and 1,200-page PDFs through the same endpoint.

The drop-in Make.com configuration

Replace your native PDF/image/media module with a single HTTP "Make a request" module configured like this:

• URL: https://api.convertfleet.com/v1/convert
• Method: POST
• Headers: Authorization: Bearer YOUR_KEY
• Body type: multipart/form-data
• Fields: file (from previous module's data), target (e.g. xlsx, docx, mp3)
• Parse response: No (binary stream)
• Timeout: 600 seconds

That is the entire conversion step. The response body is the converted file, ready to pipe directly into Google Drive, Dropbox, S3, or a Sheets append. One operation. No timeout below 10 minutes. No 5MB cap.

The format matrix you actually need

If you are coming from a brittle Make scenario, the conversions that bite hardest at scale tend to be document-heavy. The targeted endpoints worth bookmarking:

• PDF to Excel for invoice and statement batches
• PDF to Word for editable document handoffs
• HEIC to JPG for iPhone uploads into legacy CMS pipelines
• MP4 to MP3 for podcast and meeting-recording extraction
• Bank statement extraction for finance-ops automations

All of these run on the same /v1/convert endpoint — you just change the target field. One HTTP module pattern, every format your clients throw at you.

What you gain versus what you give up

Concern	Native Make modules	ConvertFleet HTTP module
Practical file size ceiling	~5-10MB	Unlimited (Business)
Operations per conversion	3-5	1
Module timeout	40s	600s configurable
Error visibility	Generic RuntimeError	JSON error body with file ID
Binary integrity across chains	Re-encoded per hop	Stream once, store once
File retention on provider	Varies, often 24h+	In-memory, no disk write
Setup time	Native UI, ~5 min	One HTTP module, ~3 min

The trade-off is a single HTTP module instead of a pre-wired connector. If you have ever debugged a CloudConvert webhook callback that arrived after the scenario already terminated, you will not miss the "convenience."

Migration checklist for an existing agency scenario

1. Sign up at convertfleet.com/signup and grab an API key from the dashboard.
2. In your existing scenario, disable (do not delete) the native conversion module so you can A/B compare output.
3. Insert the HTTP "Make a request" module with the config above.
4. Map the upstream file data field directly into the multipart file input — no base64 wrapper, no rename.
5. Map the HTTP response body straight into your downstream storage module's file input.
6. Run one cycle against your largest known-failing file. Confirm the converted output opens cleanly and parses correctly downstream.
7. Delete the disabled native module and watch your ops counter on the next billing cycle drop 60-80%.

For a deeper walk-through of the same pattern on the other major automation platform, the n8n PDF-to-Excel guide covers the equivalent HTTP-node setup with the same one-call architecture.

FAQ

What is the actual file size limit on Make.com?

There is no single documented limit — the practical ceiling is set by whichever module in your chain has the lowest cap. Inline binary handoff between modules degrades around 5MB, the native PDF modules choke around 10MB on parse-heavy documents, and the HTTP module itself can handle larger payloads but is still bounded by the 40-second per-module execution window unless you configure a custom timeout.

Will using an external conversion API actually save operations?

Yes, in almost every real scenario. Native connectors count internal polling and retry calls against your operations budget; the HTTP module counts one completed request as one operation regardless of how long the converter takes or how large the response is. Agencies typically see 60-80% reduction in ops consumption on file-heavy workflows after the swap.

Does ConvertFleet store the files I send through the API?

No. The conversion pipeline is in-memory only — files are never written to disk, and nothing persists after the response is streamed back. Per the pricing page, this is the default behavior on every plan including the free Starter tier.

Can I keep my existing Make.com error-handling routes?

Yes. The HTTP module exposes the response status code and body, so your existing error router can branch on HTTP 4xx/5xx the same way it branches on native module errors. The improvement is that the response body is a real JSON error object with a file ID and reason, instead of a generic RuntimeError string.

What about scenarios where I need OCR or layout-preserving extraction?

Both are handled on the same endpoint via the target and optional options fields. PDF-to-Excel runs layout-aware table extraction by default; image and scanned-PDF inputs trigger OCR automatically. There is no separate "premium" endpoint or per-page upcharge — it is all one API call.

Stop paying the ops tax

If you are running client work on Make.com and your monthly ops bill keeps creeping up while scenarios keep silently failing on large files, the cheapest fix is not a bigger Make plan — it is the converter underneath. ConvertFleet Pro is $5/month for life on the founder tier (first 100 accounts only), covers the conversion volume most freelancers and small agencies need, and turns every native module headache into a single boring HTTP call. The Business tier at $25 lifts the file size ceiling entirely for teams running daily six-figure-document throughput. Grab an API key, swap one module, watch your ops counter and your Slack go quiet.