Make.com + video: watermark every UGC upload automatically

A creator sends you a 4K phone clip, you want your logo in the corner before it goes anywhere, and you want it to happen without touching it. Make has no FFmpeg module, the CloudConvert "Create a job" module has no watermark operation, and the first scenario you build will stall on the file itself. The fix isn't a better module search.

Quick answer: A Make.com video watermark scenario can't run FFmpeg and can't push a creator's video through its own modules, because Make's file ceiling is per plan (5 MB Free, 100 MB Core, 250 MB Pro), so the working pattern moves a file URL to a cloud encoder instead of bytes. The direct way is ffmpeg -i clip.mp4 -i logo.png -filter_complex "[1:v]format=rgba,scale=160:-1[logo];[0:v][logo]overlay=main_w-overlay_w-24:main_h-overlay_h-24" out.mp4 on a box you keep patched. To skip the box, the FFmpeg Micro app in Make does the same stamp with Upload a File, Create a Transcode Job and Wait for Transcode Job, free to start with 200 tokens at sign-up, about 33 minutes of video.

Conventional wisdom says watermarking is the easy video job. Resizing needs decisions, captions need a transcript, but a logo in the corner is just a stamp. Most tutorials produce exactly that: one HTTP call with an overlay filter, and a declaration that you now have a pipeline. What breaks in production isn't the filter. It's everything around it, because UGC means the file arrives from a stranger, at a size you didn't choose, in batches you didn't schedule.

Draft protection and brand logos are two different watermarks

A UGC watermark pipeline has two jobs pointing in opposite directions, and they need different filters. The creator stamping an unapproved first draft wants the mark to be impossible to crop out, so a brand can't run the ad before paying. The brand stamping approved footage wants the mark small and out of the way.

PitchBrand's guide to organizing UGC deliverables describes the creator side as standard practice: deliver a watermarked review copy, release the clean file on payment, and keep the two in separate folders. The usual mark is a low-opacity centered "DRAFT - UNPAID", which in FFmpeg terms is drawtext, not overlay:

drawtext=text='DRAFT - UNPAID':fontsize=h/14:fontcolor=white@0.35:x=(w-text_w)/2:y=(h-text_h)/2

Centered and semi-transparent survives a crop. A corner logo doesn't, which is fine: the brand's logo is attribution, not protection. Build one scenario per direction and route on which folder the file landed in. If you try to serve both from one scenario with a position variable, you end up with review copies a brand can trim and ship.

Your scenario dies on the upload, not the render

Make's file documentation puts the maximum file size at 5 MB on Free, 100 MB on Core, 250 MB on Pro, 500 MB on Teams and 1,000 MB on Enterprise, with no workaround. A one-minute 4K clip off an iPhone clears 250 MB routinely. A module like Google Drive's "Download a file" fails on the exact assets your pipeline exists to process, and no plan upgrade reliably fixes it.

So don't move the video through Make at all. Move the URL. Drive, Dropbox and S3 all hand you a link or a file ID, and every step after that passes a string. Your scenario's job is to decide which file gets stamped and where the output goes, not to carry 300 MB of H.264 through a bundle.

And no, your storage provider won't do it for you. Dropbox's native watermark automation supports JPEG, PNG, BMP and PDF only. Video files aren't on the list, so there's no Dropbox automation that watermarks an MP4. Most Make Community answers on watermarking are written for still images and PDFs, and copying one into a video context gives you a recipe with no video path.

The scenario, module by module

Five modules do the whole thing, using the official FFmpeg Micro app in Make. The official app replaces the Repeater-plus-Sleep polling loop that every HTTP-module tutorial teaches, which is what burns your operations quota.

Fifteen minutes of building, and the scenario never holds a video byte. To run it from an agent instead of a scenario, the same job works through Make's MCP tooling, and the Zapier equivalent has the same no-encoder constraint.

One poll, one video, and a growing backlog

Make removed the Cycles per run scenario setting on October 1, 2026, announced on August 13 with migration guidance. Each execution runs initialization, one or more cycles, then finalization, and that setting let a single run chew through several bundles from one trigger. The release notes are the only place that says so.

The failure mode is nasty because it isn't an error. A Drive watch that returns five new creator files now processes one per execution. Nothing turns red. Your queue just grows, and you find out when a brand asks where Tuesday's clips went. If your watermark scenario used to drain a batch, either set the trigger limit to 1 and raise the schedule frequency, or push the file list into a data store and run a second scenario off it.

Running a decoder over files strangers send you

UGC watermarking is the one video workflow where the input is hostile by definition, and October 2026 is a bad month to host that decoder yourself. The October 8 CVE batch includes two that fire on the uploaded file itself, both unfixed through FFmpeg 9.0.2.

CVE-2026-107678 lets a crafted MP4 carrying tens of thousands of small pssh boxes exhaust the stack through the MOV demuxer's recursive free, with no vendor fix. CVE-2026-107676 is the worse one for this use case: when tone_mapping_flag is 0, av_dynamic_hdr_plus_to_t35() leaves up to three payload bytes uninitialized, so a crafted Matroska or HEVC/AV1 input makes your transcode write leaked process memory into the file you then publish under a brand's name.

This is the part of the job where a managed encoder stops being a convenience. FFmpeg Micro patches the binary on its side and your Make scenario only ever sees a job ID, which is the whole argument for sending the file out instead of decoding it in-house. If you do run your own build, check it against the earlier CVE-2026-96611 advisory too.

The filter string, CLI and API side by side

The watermark filter is the same graph in a terminal or posted as JSON, and the ordering inside it is where people lose an afternoon.

format=rgba has to come before scale. Put it after and scale falls back to a non-alpha pixel format, the alpha channel is gone, and your transparent PNG composites as a solid rectangle over the creator's face. This is documented in FFmpeg Micro's watermark training and almost nowhere else.

The main_w/overlay_w expressions matter just as much for UGC, where you don't control the source resolution. Hard-coded pixel coordinates that look right on 1080p land in the middle of a 4K frame. The expression form puts the logo 24 px from the corner on both, same string, no branching in your scenario.

What a stamped clip actually costs

Watermarking bills the same as a plain re-encode of the same length: the logo is an image input and images have no duration. One token buys 10 seconds of input video, metered per second with no rounding up to the minute, so a 30-second UGC clip is 3 tokens.

The free tier is 200 tokens at sign-up, about 33 minutes, or roughly 66 thirty-second clips, with no card. Starter at $19.99/month gives 2,500 tokens, about 833 clips at 30 seconds, near $0.024 a clip. Pro at $49.99 gives 7,000. Failed jobs are never billed, which is the number that matters when your inputs come from strangers' phones: a corrupt upload costs you nothing but a retry. Check the pricing page before you quote this to a client, since plan limits move.

Common pitfalls

Five watermarking mistakes cost real time, in rough order of how often they bite:

FAQ

Can Make watermark a video without an external API?

Make cannot watermark a video on its own. Make has no native FFmpeg module, no video encoder, and the CloudConvert "Create a job" module exposes no watermark operation, so every working scenario calls an outside service for the render and keeps Make for the routing.

Why does my transparent logo show up as a white box?

A transparent PNG renders as a solid rectangle when scale runs before format=rgba in the filter graph, because scale then picks a pixel format with no alpha channel and the transparency is discarded before overlay ever sees it. Reorder the graph so format=rgba comes first.

What's the largest video file I can pass through a Make module?

Make's file-size ceiling depends on the plan: 5 MB on Free, 100 MB on Core, 250 MB on Pro, 500 MB on Teams and 1,000 MB on Enterprise. There's no documented workaround, which is why a UGC pipeline should pass file URLs between modules rather than the files themselves.

Why is my scenario only processing one new upload per run?

Make removed the Cycles per run setting on October 1, 2026, so a scenario that previously drained several trigger bundles in one execution now handles one and leaves the rest queued. It shows up as a quiet backlog rather than an error, so check any watermark scenario that ran on a polling trigger.

Do I need a different setup for draft watermarks versus brand logos?

A draft watermark and a brand logo need different filters: a centered low-opacity drawtext mark that survives cropping for unpaid review copies, and a corner overlay of a logo PNG for approved footage. Run them as two scenarios writing to two folders.

The Logo Watermark blueprint does this post's job as a form: upload a clip and a logo, pick a corner and a size, download the stamped MP4. Run it once on a real creator file to see the output before you wire the Make version, free with the 200 tokens you get at sign-up.