Google Cloud Transcoder API: what it costs and when it's overkill

The Google Cloud Transcoder API is a managed batch transcoding service that bills per minute of output, $0.015 for SD, $0.030 for HD and $0.060 for UHD, and it is overkill for any pipeline that just needs one file back at one spec. Five facts decide it either way:

What the Transcoder API is genuinely good at

Google's service is built for VOD libraries, and it does that job cleanly. The overview describes managed batch transcoding with REST and RPC job submission, H.264 by default, MP4 output plus HLS and MPEG-DASH packaging, audio-only output, Cloud Storage in and Cloud Storage out. If you don't supply a custom template, the API uses preset/web-hd, the only supported preset, which gives you 1280x720 and 640x360 renditions and the manifests to go with them.

The job submission itself is small. From the quickstart, the whole first job is three fields:

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -H "X-Goog-User-Project: PROJECT_ID" \
  -d '{
    "inputUri": "gs://my-bucket/input.mp4",
    "outputUri": "gs://my-bucket/output/",
    "templateId": "preset/web-hd"
  }' \
  "https://transcoder.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/jobs"

Want one output instead of two? Then you write the config by hand, and the shape is a real streams-and-muxes graph rather than a flags list:

{
  "config": {
    "inputs": [
      { "key": "input0", "uri": "gs://my-bucket/input.mp4" }
    ],
    "elementaryStreams": [
      {
        "key": "video-stream0",
        "videoStream": {
          "h264": {
            "widthPixels": 1920,
            "heightPixels": 1080,
            "bitrateBps": 5000000,
            "frameRate": 30
          }
        }
      },
      {
        "key": "audio-stream0",
        "audioStream": { "codec": "aac", "bitrateBps": 128000 }
      }
    ],
    "muxStreams": [
      {
        "key": "hd",
        "container": "mp4",
        "elementaryStreams": ["video-stream0", "audio-stream0"]
      }
    ],
    "output": { "uri": "gs://my-bucket/output/" }
  }
}

That's an honest, well-documented API with first-party client libraries, and it beats maintaining your own encoder fleet. The part the quickstart treats as background noise is everything that has to exist before the curl works.

What one minute of video actually costs on GCP

Transcoder API pricing is metered per minute of transcoded output by resolution class, and every rendition is its own output. So the question is never "what does a minute cost," it's "how many minutes did my template produce."

Run 100 minutes through the default preset and the Transcoder line is $4.50, because the ladder bills twice. Add auto-generated subtitles to the same 100 minutes and the subtitle meter alone is $50, ten times the transcode.

Then the cost that isn't money. Enabling transcoder.googleapis.com needs the serviceusage.services.enable permission, you create a bucket, and you grant the Transcoder API service agent read on the input bucket and write on the output bucket. You learn a job finished by polling jobs.get for SUCCEEDED or FAILED, or by configuring a pubsubDestination topic, which means standing up Pub/Sub and something to consume it. Jobs carry a TTL that kicks in after completion, settable from 1 to 90 days and defaulting to 30, after which the job record disappears on its own.

There is no free allowance for the Transcoder API itself. The only on-ramp is the account-wide $300 credit over 90 days plus Google's always-free product tiers, and claiming it still requires a billing account with a card on it.

Why n8n, Make and Zapier can't reach the Transcoder API

Neither Make nor Zapier lists a Transcoder API app, and n8n has no Transcoder node. The closest path in n8n is an HTTP Request node with a Google Service Account credential explicitly switched to "Set up for use in HTTP Request node" with the right scope attached, which is the step builders trip over most often.

Even with the credential working, three things in the architecture fight a no-code orchestrator. The input has to be a gs:// URI, so your workflow needs a Cloud Storage upload step before it can submit a job. The output lands in a bucket, so it needs a signed-URL or download step after. And the documented auth pattern is Authorization: Bearer $(gcloud auth print-access-token), a token that expires in about an hour, which is a shell command, not a workflow node.

This is exactly the gap FFmpeg Micro sits in: an API key instead of a token, public URLs instead of bucket URIs, and more than 300 builders who have already run it from Make or n8n. If your FFmpeg step died when n8n 3.0 disabled community nodes, that's the same problem from the other direction.

Transcoder API versus a per-input-second processing API

The meter is the real difference, not the feature list, and the honest version is that Google's headline rate is competitive. Transcoding 100 minutes on GCP's default preset is $4.50; 100 minutes of input on FFmpeg Micro is 600 tokens, around $5 at the $25-for-3,000 top-up rate. Nobody should switch clouds over fifty cents.

Where the two meters really diverge is the ladder. One input, five renditions, bills five times on a per-output-minute meter and once on a per-input-second one. That's the same arithmetic behind what Mux's three meters cost and behind getting a plain MP4 back out of Mux.

When the Transcoder API is the right tool, and when it isn't

Use Google when your media already lives in Cloud Storage, when you're serving adaptive streams to a player, and when a GCP project, IAM posture and Pub/Sub are infrastructure you already own and staff. Packaged HLS and MPEG-DASH out of a managed job queue is worth real money, and building that on your own FFmpeg box is a project.

Skip it when the output is one file at one spec handed to the next step. Three limits make that case plain. Transcoder overlays are static images with FADE_IN and FADE_OUT animations only, so there is no equivalent of FFmpeg's drawtext for a hook caption. Inputs under five seconds are rejected, which rules out the short cuts social pipelines produce. And the API is regional, with a short supported-locations list that is mostly US regions.

FAQ about the Google Cloud Transcoder API

Is there a free tier for the Transcoder API?

The Transcoder API has no service-specific free allowance. The only way to run a job without paying for it is Google Cloud's account-wide $300 credit over 90 days, and activating that trial requires creating a billing account.

Can I pass a public video URL to the Transcoder API?

Transcoder API inputs must be Cloud Storage gs:// URIs, and an HTTP or HTTPS URL is not a valid input. A workflow holding a public file URL has to upload the file to a bucket first, which means a Cloud Storage step and credentials in front of the transcode step.

Does the Transcoder API tell me when a job finishes?

The Transcoder API reports completion two ways: you poll jobs.get until the state is SUCCEEDED or FAILED, or you set a pubsubDestination topic in the job config and consume the message. The second option is a real notification, and it costs you a Pub/Sub topic plus a subscriber you deploy and maintain. Either way you still need a poll loop that handles the failure states.

Why does one input minute cost $0.045?

The default preset/web-hd template produces both a 1280x720 and a 640x360 rendition, and Google bills per minute of each output stream. One minute in produces two minutes of billable output, $0.030 of HD and $0.015 of SD.

Is transcoding the same as encoding or remuxing?

Transcoding decodes and re-encodes, which is the expensive path. Remuxing changes only the container and copies the streams untouched, which finishes in seconds. Worth checking before you submit a job: the difference between transcode, encode, remux and compress decides whether you need a transcoder at all.

The n8n and Make walkthroughs, FFmpeg with n8n Cloud and five FFmpeg automations for Make, build the same normalize-one-upload step with no project, no bucket and no service account standing in front of it. Sign up free to get the free tier and an API key: nothing to run, no FFmpeg to install, and the same job callable from your code, from n8n, Make and Zapier, or from your AI agents.