EN ▾

Unfiltered Video API Text: An LLM Workflow for Scripts

If you searched for unfiltered video api text, the useful split is this: your renderer makes the pixels, and a text LLM API writes everything around them, from scripts and shot lists to captions and descriptions. This guide builds that text half on an OpenAI-compatible endpoint.

Updated

Film strip turning into flowing text blocks in a terminal, illustrating an LLM text workflow for video

Key points

  • The API is text only. It writes scripts, shot lists, captions and descriptions; it does not render video, images or audio.
  • Streaming gives you a script draft as it is written, and JSON mode gives you a shot list your code can parse.
  • The 100,000-token window holds a long transcript plus your instructions in one request.
  • A full text pass for one video costs a fraction of a cent at $0.15 and $0.50 per 1M tokens.

Where text fits in a video pipeline

This site's API does not generate video. It is text only: no image, audio or video output, no embeddings, no fine-tuning. That matters because the phrase gets read two ways. Some people want a model that renders clips, and for that you need a separate video model. Others already have a renderer, a stock library or an editor, and need an LLM that writes the surrounding text without refusing on subject matter that is lawful but uncomfortable: horror scripts, true-crime reenactments, dark comedy, war documentary narration, mature fiction written for adults.

The second group is who this article is for. In practice the text work around a video breaks into four jobs:

  • Script drafting. Turn an outline or a pile of notes into narration with a consistent voice.
  • Shot lists. Split a script into scenes with a duration, a visual description and a line of narration each, as JSON your editing code can read.
  • Captions and subtitle cleanup. Fix punctuation and speaker labels in a raw transcript, or write on-screen text.
  • Titles, descriptions and tags. Short outputs, many of them, which is where per-token pricing is kind to you.

The model behind the endpoint is one open-weight model run by an independent provider and tuned to answer without content refusals for lawful adult use. It is not a router across vendors and not the official API of anyone else's model. One hard limit applies: no sexual content involving minors. If you are still deciding how the audio and video halves of your stack fit together, the page on video pipelines covers the division of labour.

Connect the client

The endpoint speaks the OpenAI chat completions format, so any OpenAI SDK works after you change two values: the base URL and the key. The model ID is uncensored, and auth is a standard bearer token. Two methods exist: POST /v1/chat/completions and GET /v1/models.

from openai import OpenAI
import os

client = OpenAI(api_key=os.environ["API_KEY"], base_url="https://api.unfilteredvideo.com/v1")

# sanity check: the model list should include "uncensored"
print([m.id for m in client.models.list().data])
MODEL = "uncensored"

If you prefer the shell, the same check is one request:

curl https://api.unfilteredvideo.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"Write a two-line cold open for a ghost-story video."}]}'

You can get a key on the API key page. New accounts can claim $0.50 of trial credit with one click, valid for 7 days and with no card needed, which is plenty for everything below.

Step 1: stream a script draft

A script is the longest output in the pipeline, so it is the one worth streaming. With stream: true the server sends tokens over SSE as they are produced, and the usage numbers arrive at the end of the stream. Your editor tool can show the draft growing instead of freezing for the full generation.

from openai import OpenAI
import os

client = OpenAI(api_key=os.environ["API_KEY"], base_url="https://api.unfilteredvideo.com/v1")

outline = """Cold open: abandoned lighthouse at night.
Act 1: the keeper's logbook, last entry torn out.
Act 2: the tide table that does not match the moon.
Close: the lamp turns on by itself."""

stream = client.chat.completions.create(
    model="uncensored",
    stream=True,
    temperature=0.9,
    messages=[
        {"role": "system", "content": "You write narration for short horror videos. Second person, present tense, about 90 seconds spoken."},
        {"role": "user", "content": outline},
    ],
)

script = []
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        piece = chunk.choices[0].delta.content
        script.append(piece)
        print(piece, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\n\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

script = "".join(script)

Two details are easy to miss. First, the last chunk can carry usage and no choices, which is why the loop checks chunk.choices before indexing. Second, a streamed request holds its concurrency slot until the stream ends. If your tool lets users start several drafts at once, count each open stream against your limit.

Voice is the thing that drifts across a series. Put the channel's rules in the system message and keep them fixed: narrator person and tense, sentence length, words to avoid, how a cold open should end. Add a short list of things the script must never do, such as explaining the twist early. A stable system message also makes your token counts predictable from one video to the next, which helps when you budget later.

For repeatable drafts while you tune a prompt, pass seed with a fixed value and a lower temperature. For a first creative pass, a temperature around 0.8 to 1.0 gives looser, livelier narration, and you can drop it once you are polishing.

Step 2: turn the script into a shot list

Editing code wants structure, not paragraphs. JSON mode asks the model to return a single JSON object, and you enable it with response_format. Also say the word JSON in your prompt and describe the shape you want; the two together keep the output on shape.

import json, os
from openai import OpenAI

client = OpenAI(api_key=os.environ["API_KEY"], base_url="https://api.unfilteredvideo.com/v1")

def shot_list(script_text):
    resp = client.chat.completions.create(
        model="uncensored",
        response_format={"type": "json_object"},
        temperature=0.3,
        messages=[
            {"role": "system", "content": (
                "Return JSON only: {\"shots\": [{\"n\": int, \"seconds\": number, "
                "\"visual\": string, \"narration\": string}]}. "
                "Keep each shot between 3 and 8 seconds."
            )},
            {"role": "user", "content": script_text},
        ],
    )
    data = json.loads(resp.choices[0].message.content)
    return data["shots"]

for s in shot_list(script):
    print(s["n"], s["seconds"], s["visual"][:60])

JSON mode makes bad output rare, not impossible. Wrap json.loads in a try block, retry once with a lower temperature, and validate the fields you depend on. A shot list with a missing seconds value will break a timeline far more loudly than a slightly clumsy sentence.

Pass the visual strings to whatever generates or selects your footage. Because the model is not asked to be cautious about subject matter, descriptions of grim or tense scenes come back as written briefs rather than polite refusals. Keep your own review step in the loop for anything you publish.

Step 3: captions and descriptions from a long transcript

The context window is 100,000 tokens, prompt and completion together. For text work on video that is generous: a long interview transcript, your channel style guide and three example descriptions fit in one request, so you do not need to chunk and stitch the way you would with a small window. Check the real size from the usage field rather than guessing, and leave room for the output.

import OpenAI from "openai";
import fs from "node:fs";

const client = new OpenAI({
  apiKey: process.env.API_KEY,
  baseURL: "https://api.unfilteredvideo.com/v1",
});

const transcript = fs.readFileSync("interview.txt", "utf8");

const res = await client.chat.completions.create({
  model: "uncensored",
  temperature: 0.4,
  messages: [
    { role: "system", content: "You write video metadata. Reply with a title under 70 characters, a 3 sentence description, and 8 tags separated by commas." },
    { role: "user", content: transcript },
  ],
});

console.log(res.choices[0].message.content);
console.log(res.usage);

For subtitle cleanup, split by time instead of by size. Send a few minutes of raw transcript at a time with the instruction to keep timestamps untouched, then merge. If you also need on-screen captions that match a house style, put the style rules in the system message and keep them identical across calls; it makes outputs consistent and makes the token count predictable.

Tool calling is available too, if you want the model to call your own functions, for example a lookup_asset function that checks your footage library for a matching clip while it writes the shot list. Define the tools, read tool_calls from the reply, run them, and send the results back as role: "tool" messages.

Limits that shape the pipeline

A full key allows 8 concurrent requests and 300 requests per minute. A trial key allows 2 concurrent and 60 per minute. The body limit is 8 MB, which is far above any transcript you will send as text. Past a limit you get HTTP 429 with the error code rate_limited (too many per minute) or concurrency (too many at once). On temporary overload you also get a 429, with a Retry-After: 5 header.

The simple rule: on any 429, wait for the header value if there is one, otherwise back off for a few seconds, then retry. Failed or refused requests are not charged, so retries do not cost you. Responses include X-Request-Id for support questions and X-Balance-USD, which is handy for showing remaining credit inside your own tool.

When you render many videos in parallel, give the text stage its own small worker pool of 4 to 6 so that a burst of drafts cannot starve the shot-list step. Streams count against concurrency the whole time they are open, so a user who walks away from a half-read draft still holds a slot until it finishes.

What the text side of one video costs

Pricing is $0.15 per 1M input tokens and $0.50 per 1M output tokens, from prepaid credit with no subscription. Here is a realistic text pass for a 90-second video, with the math shown:

StepInput tokensOutput tokensCost
Script draft6001,200600 × $0.15/1M = $0.00009, plus 1,200 × $0.50/1M = $0.0006, total $0.00069
Shot list1,500900$0.000225 + $0.00045 = $0.000675
Title, description, tags1,800300$0.00027 + $0.00015 = $0.00042

The three steps add up to $0.001785 per video. A thousand videos is $1.785 of text. Even if your real prompts are three times longer than these, the writing is the cheap part of the job. The $0.50 trial credit alone covers more than 250 videos at these sizes, since $0.50 divided by $0.001785 is about 280.

After the trial, credit comes from top-ups of any whole amount from $20 to $500, paid in crypto (USDT on TRC20 or USDC on Base). Bonuses apply on larger top-ups: +5% from $50, +10% from $100, +15% from $200. Credit never expires, and prompts are not used for training. The pricing page lists the details, and the quickstart has the same request format in a few more languages.

Questions and answers

Can this API generate video?

No. It is text only, with no image, audio or video generation. Use it for scripts, shot lists, captions and descriptions, and pair it with the renderer or editor of your choice.

Does it refuse dark or mature subject matter?

The model is tuned to answer without content refusals for lawful adult use, so horror, crime and mature fiction for adults are workable. Sexual content involving minors is a hard no.

Which model ID and base URL do I use?

Use the model ID uncensored and the base URL https://api.unfilteredvideo.com/v1 with any OpenAI-compatible SDK. Authenticate with a bearer token.

Is there a free tier?

There is no free tier. New users can claim a one-time $0.50 trial credit, valid for 7 days, with no card; after that you top up from $20.

Your key is one form away

Create an account, copy the key, change the base URL. That is the whole setup.

Get API key