Run every video
through your pipeline.
Editframe Factory runs transcription, your own models, human review and redaction on large volumes of video, then renders branded clips from the results. Each file enters the pipeline while it is still uploading. Factory runs hosted by Editframe. On-prem options are available for your own cloud or data center.
Film outline
- Every night, 4,000 trucks upload dashcam video. Kestrel Freight wants a reviewed safety clip of every hard brake. Tonight its trucks upload 1,200 hours of dashcam video, more than anyone can watch.
- Each video plays and processes before its upload finishes. Editframe's uploader sends each truck's video in parts that start on a keyframe, so playback and processing begin while the rest uploads. Factory uses a part only after its checksum matches.
- Your pipeline starts on each part as it arrives. Probe, transcribe and frame sampling run on each part, while filter, review, redact and publish wait for the whole video. The pipeline is a versioned JSON graph. Each run keeps its version, and each step adds results to the video's record and sends a pipeline_step.completed webhook.
- Your model is a step too. Factory sends your model or service a signed request with an idempotency key and the part's frames and transcript, up to the concurrency limit you set. Your service can return a result now, return it later by callback, or ask Factory to retry later. Kestrel's model returns a hard brake with keyframed plate boxes.
- Only flagged moments reach a reviewer. The filter step passes on only the moments your model flagged. The video waits at review until Ana, a Kestrel reviewer, approves blurring one license plate, and then your app receives a webhook.
- Factory renders a branded clip your team can edit. Redact blurs the plate along the boxes your model returned, and the clip carries captions from the transcript and a Kestrel lower third. Publish adds an internal playback link to the video's record. The same composition opens in an Editframe editor inside Kestrel's app, and each edit renders again.
- Workers follow the queue. Factory starts more workers as tonight's queue grows and stops them when it empties. Calls to your model stay within the limit you set. Timing in this scene is illustrative.
- All 1,200 hours were checked. Every part went through the same steps, and people saw only the moments Kestrel's model flagged. Kestrel is one example. Your pipeline can use the same steps and your own models. Factory runs hosted, and on-prem options are available.
For teams that collect more video than people can watch.
Fleets, insurers, security teams and media archives record footage around the clock. Factory runs the same checks on every file, asks a person to decide only where a step flagged something, and returns clips your staff and customers can use.
Reviewers see flagged moments.
A filter step sends only the files your model flagged to the review queue. Every other file finishes without waiting for a person.
Every result is in one record.
Each step adds its results to the video's record, so search, reporting and audits read from one place.
Capacity follows the batch.
Workers scale with the queue of waiting video and stop when it empties.
Approved moments become clips.
Redact and publish render through Editframe, so each approved moment becomes a branded clip your team can edit.
A pipeline is a versioned JSON graph.
Each step names the steps it needs, and Factory starts a step when its inputs are ready. A run keeps the pipeline version it started with, so you can publish a new version without changing files already in flight.
Built-in steps probe, transcribe, sample frames, detect scenes, filter, review, redact and publish. Your app receives a webhook such as pipeline_step.completed for each step, with a sequence number per run so you can apply events in order.
{
"steps": {
"probe": { "type": "probe" },
"transcribe": { "type": "transcribe", "needs": ["probe"] },
"frames": {
"type": "sample_frames",
"needs": ["probe"],
"with": { "every_ms": 1000 }
},
"your_model": {
"type": "endpoint",
"needs": ["transcribe", "frames"],
"with": { "endpoint_id": "ep_brakes", "max_concurrency": 64 }
},
"flagged": {
"type": "filter",
"needs": ["your_model"],
"when": { "path": "your_model.annotations", "op": "non_empty" }
},
"review": { "type": "review", "needs": ["flagged"] },
"redact": {
"type": "redact_render",
"needs": ["review"],
"with": { "kinds": ["plate"] }
},
"publish": { "type": "publish", "needs": ["redact"] }
}
}Your model is one of the steps.
Register an endpoint and Factory calls it with the file, signed media URLs and the metadata earlier steps wrote. Each request is signed, carries an idempotency key and stays within the concurrency limit you set for that endpoint.
Receive the step
The request names the run, the step and the attempt. If a retry repeats a request you already handled, the idempotency key lets you recognize it.
{
"pipeline_run_id": "run_8c1f…",
"step_run_id": "stp_42d0…",
"attempt": 1,
"idempotency_key": "stp_42d0…:1",
"file": { "id": "file_1182…", "duration_ms": 1080000 },
"media": {
"source": "https://…/source.mp4",
"frames": "https://…/frames/"
},
"metadata": { "transcribe": { … }, "frames": { … } },
"callback_url": "https://…/callbacks/stp_42d0…"
}Answer now or call back
Return 200 with this result, or 202 and post it to the callback URL when your model finishes. Factory backs off on 429 and honors Retry-After.
{
"metadata": { "event": "hard_brake" },
"annotations": [
{
"kind": "plate",
"start_ms": 487000,
"end_ms": 496000,
"keyframes": [
{ "t_ms": 487000, "x": 0.6, "y": 0.52, "w": 0.05, "h": 0.06 }
]
}
]
}Factory uses the rest of Editframe.
The redact step renders through the same composition model as the rest of Editframe. Render branded clips from pipeline results, put an editor in your product, and play the source through on-demand segments.
Tell us about the batch.
Describe the footage, how much arrives each day and the cloud it lives in. We reply to the work email you send.