cloudinaryapimigration

Migrate off Cloudinary video and the encode is the easy part

··11 min read
Migrate off Cloudinary video and the encode is the easy part

Migrate off Cloudinary video and the processing is the easy part. What you actually give up is four conveniences you were never billed for as line items, plus one job you now own.

  • Cloudinary builds a derived asset the first time someone requests a transform URL, then caches it for everyone after. A processing job runs once, when you ask, with no visitor waiting on it.
  • f_auto and q_auto choose a format and a compression level per browser at request time. A processing job returns one file in the one format you named.
  • The delivery URL is a CDN address you can paste into a <video> tag. A job hands back a download, not a place to host it.
  • The Cloudinary Video Player wraps that URL in adaptive playback, captions and analytics, and a processing API ships no player at all.
  • The operational one: a job returns a file that you now have to store somewhere and name yourself.

Every migration guide for this is written by whoever wants your library next, so none of them itemizes that list. Price it honestly and the switch still makes sense for most video work, but for a reason that has nothing to do with features.

What the transform URL was doing for free, and what it cost

Migrate off Cloudinary video and the first thing that stops happening on its own is the encode. A Cloudinary video transformation is lazy by design. The first request for /video/upload/w_1080,ar_9:16/clip.mp4 triggers the encode, the result is stored as a derived asset, and every later request hits cache. Nobody writes a poll loop. Nobody picks a filename.

That derived asset isn't free, it's just billed somewhere you weren't looking. Cloudinary's credit math counts each second of SD video as two transformations and each second of HD as four, with one credit buying 500 SD seconds or 250 HD seconds, and derived files sit against your storage quota as long as they exist. The arithmetic is in what a Cloudinary credit actually buys for video. Three renditions of one clip is three derived assets, and f_auto multiplies that, since each negotiated format is another derived file.

The lazy encode also has a ceiling. Cloudinary's troubleshooting docs cap on-the-fly video transformation at 40 MB on Free plans and return Video is too large to process synchronously, please use an eager transformation with eager_async=true above it. Eager transformations exist so the first visitor doesn't wait on an encode, which means past a fairly small file you were already running an async job API. You just called it something else and didn't get the file back.

Format negotiation is worth a lot, until the output is an MP4

f_auto resolves per request at the CDN, delivering VP9 WebM or AV1 MP4 to most modern browsers, HEVC MP4 to Safari, and H.264 MP4 as the fallback. For a hero video on your own marketing page, that's real bandwidth saved on every view, and one cost breakdown puts CDN egress at 50% to 70% of a streaming bill against 10% to 20% for encode (Spendark).

Now look at what your pipeline actually produces. A 9:16 cut going to TikTok's Content Posting API. A 4:5 creative going into Meta Ads. A 15-second clip going on an Etsy listing. An MP4 attached to an email.

Every one of those destinations re-encodes what you send and every one accepts H.264 MP4, so per-browser negotiation has nobody to negotiate with. You picked the format the moment you picked the platform.

Format negotiation pays when you own the playback surface. It pays nothing when the file's next stop is somebody else's uploader.

The delivery URL isn't an asset for a publishing pipeline

When you migrate off Cloudinary video, giving up the delivery URL sounds like the expensive part, and for an on-site player it is. For a pipeline that ends on someone else's platform, it's something you have to undo anyway.

TikTok's Content Posting API makes this concrete. Its PULL_FROM_URL source requires the URL to sit under a domain whose ownership you've verified, and returns url_ownership_unverified with HTTP 403 otherwise, while FILE_UPLOAD requires no domain verification at all (TikTok for Developers). You can't verify ownership of a Cloudinary delivery domain. So a pipeline ending at TikTok either fetches the bytes off the delivery URL and uploads them as a file, or it doesn't publish. Meta's Graph API container flow and most schedulers want the same thing: bytes, or a URL on infrastructure you control.

A job API that hands back a finished file skips a step there instead of adding one.

The player is the one real loss, and you can keep the player

The Cloudinary Video Player is the only item on this list a processing API has no answer for. It adds adaptive bitrate playback with HLS and MPEG-DASH generated from one source asset, plus captions, playlists, analytics and a customizable UI, all attached to Cloudinary delivery.

If you need that, keep it. Nothing about moving a transcode step forces you to move playback, which is the whole argument in replace Cloudinary video on one step, not the whole library. FFmpeg Micro will package HLS variants for you, but it doesn't deliver them, doesn't ship a player and reports no watch-time analytics. When the product is a video page with an engagement dashboard, a managed streaming platform is the right class of tool and a processing API is not.

A job hands you a file, so you now own storage and naming

A transform URL was also your storage layer, cache key and filename convention, and none of it showed up as a line item. A job API returns an output and then stops caring. You need a bucket, a key scheme and a rule for what happens when the same input is submitted twice.

In practice that's about fifteen lines of workflow, and most teams already have the bucket, since the source video sits in S3, Google Cloud Storage, Drive or Dropbox before any of this starts. The piece worth building deliberately is the key: something like renders/{asset_id}/{preset}/{content_hash}.mp4, so a retry overwrites instead of duplicating. That matters more in no-code, as anyone who has watched an n8n workflow run twice and render every video twice knows.

The same job as a processing call, against a file you already host:

curl -X POST https://api.ffmpeg-micro.com/v1/transcodes \
  -H "Authorization: Bearer $FFMPEG_MICRO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": [{"url": "https://storage.example.com/master.mp4"}],
    "outputFormat": "mp4"
  }'

You poll that job until it reports completed, download the output, and write it to your own key. Billing is on input duration, metered per second with no rounding up to the minute, and failed jobs are never billed, so a malformed request or a corrupt source costs nothing. A 10-minute master is 60 tokens whether the output is 360p or 2160p, and nothing bills again after the job finishes. The one job, not a URL post maps common transformation strings onto their job equivalents.

Cloudinary video is reachable from n8n and Make now. It returns a URL.

The old line that Cloudinary video transforms were unreachable from no-code tools is out of date. Cloudinary ships an official n8n community node with Video operations for Optimize, Resize, Crop, Trim and Thumbnail, plus a player embed builder (cloudinary/n8n-nodes-cloudinary), Make exposes Cloudinary modules including Upload a Resource, Transform a Resource and Make an API Call (Make integrations directory), and Zapier has an integration too.

The sharper distinction is what those Transform operations hand into the workflow: a delivery URL, output as secure_url plus a reusable transformation string. That's an address, not a file, and it stays a live dependency on Cloudinary delivery that meters bandwidth every time something fetches it. Your next module, the one uploading to TikTok or writing to Drive, still has to go get the bytes.

Cloudinary video transform URLProcessing job
When the encode runsOn the first request, or eagerly past the sync size capWhen you submit the job
What the next step receives`secure_url` to a hosted derived assetA download of the output file
Who stores the outputCloudinary, against your storage quotaYou, in your own bucket
Billing after the jobStorage plus delivery bandwidth, monthlyNothing
Per-browser format negotiationYes, via `f_auto` and `q_auto`No, one named output format
Player and analyticsYesNo
Failed workCounted against transformation quotaNot billed

Where this switch goes wrong

Plans to migrate off Cloudinary video fail in a few predictable ways, all of them from treating it as a platform migration instead of a step swap.

  1. Moving the library when you only needed to move the step. Images, the DAM, the player and existing delivery URLs stay where they are. Replace the transform call and nothing in your front end changes.
  2. Hardcoded delivery URLs in email and in published posts. Those URLs sit in sent newsletters and indexed pages you can't edit. Keep the assets alive, keep paying the small storage line, and point only new renders at the new path.
  3. No deterministic output key. Without a content hash or asset ID in the filename, retries and duplicate workflow executions produce output (2).mp4 forever. Decide the key before you submit the first job.
  4. Assuming f_auto was buying nothing. On a site where you own the player and serve the same hero video a hundred thousand times, per-browser negotiation is real money. Measure your split between on-site playback and files shipped elsewhere before calling it worthless.
  5. Comparing plan prices instead of meters. A transform-and-deliver product bills on transformations, storage and bandwidth every month the asset exists. A processing API bills once, on input duration. The comparison only means something once you've modeled a real month of your own footage, the exercise in which Cloudinary alternatives hand the file back.

FAQ about migrating off Cloudinary video

Can I keep Cloudinary for images and move only the video transformations?

You can migrate off Cloudinary video transformations and keep Cloudinary for images, and that's the normal shape of this change rather than a compromise. Image transform URLs, the DAM and the Video Player don't depend on who runs your video encodes, so you can swap one /video/upload/ transformation for a job call and leave every image URL untouched.

Does f_auto matter if my video is going to TikTok or Meta?

Per-browser format negotiation is worth nothing when the output is a finished MP4 bound for TikTok, Meta, YouTube or an email attachment, since each of those platforms re-encodes your upload and all accept H.264 MP4. f_auto earns its keep only on playback surfaces you control.

At what file size does Cloudinary stop transforming video on the fly?

Cloudinary's troubleshooting documentation puts the on-the-fly video transformation limit at 40 MB on Free plans, above which the API tells you to use an eager transformation with eager_async=true. The cap varies by plan, so check the figure for yours.

Where do I put the file a video API hands back?

Write the output of a processing job to the same storage you already keep source video in, whether that's S3, Google Cloud Storage, Supabase Storage, Drive or Dropbox, under a deterministic key such as renders/{asset_id}/{preset}/{hash}.mp4. Deterministic naming makes a retried job overwrite its previous output instead of creating a second copy.

Does Cloudinary's n8n node give me the video file?

Cloudinary's official n8n community node returns secure_url and a reusable transformation string from its Video Transform operations, which is a delivery address rather than binary data in the workflow. Any module after it that needs actual bytes, such as a TikTok or Drive upload, has to fetch the file from that URL first.

Point one real job at a video you already store, watch the poll loop reach completed, and write the output into your own bucket. Sign up free starts you with 200 tokens, roughly 33 minutes of video and no card: no servers to run, no FFmpeg to install, and the same call works from your code, from n8n, Make and Zapier, or from an AI agent.

About Javid Jamae

Founder & CEO at FFmpeg Micro

Javid is a software engineer, author, and entrepreneur with over 25 years of professional software development experience across enterprise, startup, and consulting environments. He founded FFmpeg Micro to make video processing accessible to developers through a simple, automation-first REST API.

Software EngineeringVideo ProcessingFFmpegCloud ArchitectureAPI DesignAutomation

Ready to process videos at scale?

Start using FFmpeg Micro's simple API today. No infrastructure required.

Get Started Free