Video by hand is work.Video on the API is part of your product.
Uploading one by one, waiting for it to process, copying the embed, watching the screen to know when it's ready. Every video becomes a manual task. With the Moviie API your backend reserves the upload, generates subtitles, clips, and ebook, grabs the embed, and gets a signed webhook the instant the video is ready. The pipeline runs without anyone opening the dashboard. Versioned REST at api.moviie.ai/v1, a private key, published OpenAPI, a signed webhook. All documented, with an example that runs.
Video that isn't your coreeats the time that should go to the product.
Bezos called it muck: the heavy lifting that doesn't differentiate your business. His 2006 estimate was that 70% of the effort to build a product was undifferentiated work. Twelve years later IDC put it at 80%. Running video by hand is exactly that work. Unless video is your product, every hour spent pushing files through the dashboard is an hour that didn't go to what sets you apart.
Without an API, every video is a file dragged onto the screen, a progress bar to watch, an embed to copy and paste into the right place. Multiply that by a catalog that grows every week and video becomes a manual work queue that never ends.
How Moviie solves itWithout a webhook, you find out the state of the video by asking. You end up polling, rigging a makeshift queue, refreshing the screen to see if it processed yet. And when the notice finally lands, it lands unsigned, with no way to trust where it came from.
How Moviie solves itGenerating clips, ebook, subtitles, and dubbing by clicking, video by video, doesn't scale with the catalog. What should be a step in your pipeline becomes one more screen someone has to open, on someone's time, every single time.
How Moviie solves itThe video goes into your code.And stops being a task.
At Moviie the entire video cycle is API. Your backend uploads, generates, grabs the embed, and gets notified. Versioned REST to drive the library, AI calls for the materials, and a signed webhook to react at the right moment. The dashboard still exists, but nothing in the pipeline depends on it.
Upload, list, update, organize, all on /v1.
The versioned REST API at api.moviie.ai/v1 drives the library from your backend. Reserve an upload, list and search by reference_id (your own id tied to the video), update, delete, organize into collections, and pull audience analytics. It authenticates with a private Bearer key, and the published OpenAPI generates the client in your language without guessing the contract.
- Versioned /v1 base, no breaking changes without notice
- Videos, Collections, Analytics, and Me
- reference_id to tie it to your database
- Published OpenAPI to generate the client
Clips, ebook, quiz, dubbing, each in one call.
The video's AI materials aren't locked in the dashboard: each one is an endpoint. You generate vertical clips, ebook, quiz, and voice-cloned dubbing, and each call returns right away with a job you poll. Generation runs in the background and debits credit, with a full refund if the job fails.
- Clips, ebook, quiz, and dubbing by API
- Runs async, with a job to poll
- Debits credit, refunded if it fails
- Idempotent: an identical request in progress isn't charged again
The webhook calls you, you don't keep asking.
The instant the video is ready, a subtitle finishes, or bandwidth crosses a threshold, the webhook lands on your endpoint. A granular catalog you switch on per endpoint, an HMAC-SHA256 signature on every delivery, an attempt counter in the header, and automatic retry up to six times with backoff. A failure only becomes an event after a job confirms it, no false alarms.
- Granular catalog, switched on per endpoint
- HMAC-SHA256 signature on every delivery
- Up to 6 attempts, with backoff and X-Moviie-Attempt
- Failure confirmed by a job, no false alarm
Running video by handand running it through the API.
The final video is the same. What changes is who does the work: you in the dashboard, or your backend on its own.
| Video by hand | Moviie API | |
|---|---|---|
| Upload the video | drag onto the screen, one by one | POST /uploads/reserve |
| Know it's ready | refresh and look | webhook video.ready |
| Grab the embed | copy and paste by hand | GET /videos/{id}/embed |
| Generate clips, ebook, dubbing | click, video by video | one call per material |
| Trust the notice | no way to trust it | HMAC signature on every delivery |
| Tie it to your database | a spreadsheet on the side | reference_id on the video itself |
Both put the same video live. On one, the work is yours. On the other, it's your backend's.
One API.The whole platform behind it.
Scoped keys
Private on the server to drive the library, publishable on the client to play. Each part with the minimum it needs, without exposing the key that commands.
Private video by token
Mark the video private and it serves nothing without a short JWT your backend signs. The protection lives on the same platform as the API. Full detail on the developers page.
Player API by events
When the topic is controlling the player in the browser, that's the Player API by events. It lives on the developers page, outside the scope of this one.
The dashboard mirrors the API
Everything the API does, the dashboard shows: key, webhooks, and signing secret come from there. Code and dashboard move together, not against each other.
Hit the limit? 429 with Retry-After
Rate-limited endpoints respond 429 with Retry-After, and generation with no balance responds 402 with how much is short. Predictable error, documented, easy to handle.
Everything unlocked on your plan
API and webhooks come on every plan, along with the rest. Plans change the bandwidth, storage, and credit quota, not the list of features.
What you can automateand how it behaves.
No. The REST API and AI generation use a private key (prefix mvi_), created on the dashboard in Settings → API Keys, and every call has to come from your backend. For the client there's the publishable key, scoped to playback only. The key that drives the library never shows up in the browser.
You can. Each AI material is an endpoint: reels, ebook, quiz, and lipsync. The call returns right away with a job, generation runs in the background and debits credit, with a full refund if the job fails. An identical request already in progress is reused, not charged again.
Every delivery arrives signed with HMAC-SHA256 in the X-Moviie-Signature header, computed over the raw body. You check the signature before reading the body, with the signing secret that comes from the dashboard. If a delivery fails, Moviie tries again: up to six times, with quadratic backoff, and the attempt number comes in X-Moviie-Attempt.
The API has published OpenAPI, so you generate the client in your language from the contract, without guessing the payload and without depending on an SDK that lags behind. The whole contract is at docs.moviie.ai, with an example that runs on every endpoint.
The path is uploading the file: you reserve the slot with POST /v1/videos/uploads/reserve and send the file to the signed upload endpoint it returns. From there the video is yours on Moviie, with embed, AI, and webhook. The API drives the cycle of the video that's on the platform.
Take the video off the screen.Put it in your backend.
A 14-day trial to reserve an upload, generate the materials, and receive the signed webhook on your endpoint. OpenAPI and examples ready to go, the whole contract at docs.moviie.ai. No sales call.