Cloud

Ittybit Cloud runs your media processing jobs on distributed GPU infrastructure. You send files via the CLI or API, and we handle queues, workers, scaling, retries, and monitoring.

Cloud is the default when you have an API key set. No additional flags or configuration required.

Creating a job

ittybit video -i input.mov --quality high

const task = {
  kind: 'video',
  input: 'https://example.com/input.mov',
  quality: 'high',
};

const res = await fetch('https://api.ittybit.com/jobs', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.ITTYBIT_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(task),
});

import requests

task = {
    "kind": "video",
    "input": "https://example.com/input.mov",
    "quality": "high",
}

res = requests.post(
    "https://api.ittybit.com/jobs",
    headers={"Authorization": f"Bearer {api_key}"},
    json=task,
)

curl -X POST https://api.ittybit.com/jobs \
  -H "Authorization: Bearer $ITTYBIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "kind": "video",
    "input": "https://example.com/input.mov",
    "quality": "high"
  }'

Jobs are processed asynchronously. The response includes a job ID you can use to check status or set up a webhook for completion notifications.

How it works

When you submit a job, ittybit:

1. Ingests the source file from a URL or your connected storage
2. Splits the file at keyframe boundaries into segments
3. Encodes segments in parallel across GPU workers
4. Reassembles the output and uploads it to your storage
5. Notifies you via webhook or polling

This is why a 2-hour lecture that takes FFmpeg 97 minutes to encode finishes in 53 seconds on ittybit Cloud.

Scaling

Cloud scales automatically in both directions:

• Scale up: submit thousands of files at once and they process in parallel across the fleet. No provisioning, no capacity planning, no queue configuration.
• Scale down: when you’re not processing, you’re not paying. No idle instances, no reserved capacity.

Retries and error handling

Transient failures (network timeouts, temporary worker unavailability) are retried automatically with exponential backoff. You don’t need to build retry logic into your application.

Unrecoverable errors (unsupported codec, corrupt source file) return immediately with a structured error response including a kind field and an actionable message. See the errors reference for the full list.

Storage

By default, processed files are stored in ittybit’s managed storage and accessible via a signed URL in the job response.

To use your own storage, configure an S3-compatible connection:

ittybit connections add --name my-bucket --bucket my-bucket --region us-east-1

Then specify the output destination:

ittybit video -i input.mov -o s3://my-bucket/output.mp4

See process files from S3 and write output to S3 for more.

Pricing

Pay per minute of output produced. No subscriptions, no reserved capacity, no minimum spend. No storage surcharges, no egress fees.

View pricing →

Local processing

If you have FFmpeg installed, you can process files locally without an API key:

ittybit video -i input.mov -o output.mp4 --quality high --local

The CLI, flags, and output format are identical. The only difference is where the processing runs. See the CLI reference for the full command list.