EN ▾

OpenAI-compatible uncensored LLM APIuncensoredapis.com

HomeAgents

LLM API Free Trial: What to Test in the First Hour

Isometric checklist tiles connected to a server cube and coins, representing a first-hour API trial test plan

An llm api free trial is short and small, so the point is to learn fast whether the endpoint fits your project. This checklist covers what to test in the first hour and how far $0.50 of credit stretches.

Updated

Key points

  1. The trial is $0.50, claimed with one click on the API key page, valid 7 days, no card.
  2. Test in this order: models list, plain chat, streaming, tool calls, JSON mode, limits.
  3. Trial keys allow 2 concurrent requests and 60 requests per minute.
  4. $0.50 covers roughly 900 requests of 2,000 input and 500 output tokens.

What the trial gives you

New users can claim $0.50 of trial credit after sign-up. You sign up with Google or with email and password, open the API key page and press one button. There is no card to enter, the credit is valid for 7 days, and it is one trial per person.

The API is OpenAI-compatible, so anything that talks to the OpenAI SDK works after you change the base URL and the key. The model ID is always uncensored. It is one open-weight model run by an independent provider and tuned to answer without content refusals for lawful adult use, with a 100,000-token context window. It is text only: no images, audio, embeddings or fine-tuning.

Seven days is plenty if you plan the work, and the trial is only useful if you actually run real prompts through it. Do not test with "hello world" alone; use the kind of input your product will send, including long documents, odd formatting and the topics your users care about. Spend the first hour on the checks below, then decide whether to top up from $20 or walk away.

Step 1: create the key and list the models

Go to the API key page, create a key and claim the trial. Store the key in an environment variable rather than in code.

export API_KEY="sk-your-key"
curl -s https://api.uncensoredapis.com/v1/models \
  -H "Authorization: Bearer $API_KEY"

A JSON list that contains uncensored proves three things at once: the base URL is right, the key is accepted and Bearer auth works. If you get a 401, the key is wrong or has a stray space. The API reference walkthrough explains the response fields.

Step 2: send a plain chat request

Before any advanced feature, check the basic path and read the response headers. Add -i to curl to see them.

curl -i https://api.uncensoredapis.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [{"role": "user", "content": "Explain DNS in two sentences."}]
  }'

Look for X-Request-Id (quote it if you ever contact support), X-Balance-USD (your remaining credit after the call) and the two X-RateLimit-Limit-* headers. Run the same request twice and watch the balance drop by a tiny amount. That confirms billing works the way you expect. max_tokens is optional, so you do not need it for this test.

Step 3: test streaming

If your product shows text as it is typed, streaming is the feature to prove early. Set stream: true and read server-sent events.

from openai import OpenAI

client = OpenAI(base_url="https://api.uncensoredapis.com/v1", api_key="sk-your-key")

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a four-line poem about servers."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\nusage:", chunk.usage)

Usage arrives at the end of the stream, which is where you read token counts. One detail matters for later: a streamed request holds its concurrency slot until the stream finishes, so a client that never closes streams will eat into your limit.

Step 4: tool calls and JSON mode

Agents and data pipelines depend on these two features, so give each a real test with your own schema, not a toy one.

Tool calling

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up an order by its ID",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]
resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Where is order A-1042?"}],
    tools=tools,
)
print(resp.choices[0].message.tool_calls)

Check that the arguments parse as JSON and match your schema. Then send the result back as a message with role: "tool" and confirm the model answers from it. The agents and tool calling page shows the full loop.

JSON mode

Pass response_format={"type": "json_object"} and say the word JSON in the prompt. Run ten varied inputs and parse every reply with json.loads. One failure in ten tells you to add validation and a retry in your code.

Step 5: hit the limits on purpose

A trial key allows 2 concurrent requests and 60 requests per minute. A full key gets 8 and 300. Go over a limit and the API returns HTTP 429, with the error code rate_limited for requests per minute or concurrency for too many at once. Temporary overload also gives a 429, with a Retry-After: 5 header.

Fire five requests in parallel and make sure your client backs off and retries instead of crashing. This is the cheapest bug to find now. See errors and rate limits for the retry pattern. Failed or refused requests are not charged, so these tests cost almost nothing.

Common trial problems and fixes

  • 401 on every call: the key has a stray space or newline, or the header is not Authorization: Bearer .... Print the header length in your code to catch this.
  • 404: the base URL lacks /v1, or the SDK appends the path twice. Use the base URL exactly as written in this article.
  • 429 during a short test: trial keys allow only 2 requests at once. Run tests in sequence, or add a small semaphore around your calls.
  • Balance not moving: read X-Balance-USD from the raw response, not from a cached value. Each call costs a fraction of a cent, so compare to four decimal places.
  • Truncated answers: check finish_reason. If it says length, you set a low max_tokens. The setting is optional and the completion can use the rest of the 100,000-token window.

Keep a short log of what you ran and what you saw. After the hour, you should be able to say yes or no to three questions: does the API behave like OpenAI where my code needs it to, does the model answer my kind of prompts without refusing, and does the cost per task fit my budget? If all three are yes, top up. If not, you have lost nothing but a few cents of trial credit.

How far $0.50 goes

Prices are $0.15 per 1M input tokens and $0.50 per 1M output tokens. Three sample workloads:

RequestCost per callCalls from $0.50
1,000 input, 500 output$0.00015 + $0.00025 = $0.00041,250
2,000 input, 500 output$0.0003 + $0.00025 = $0.00055about 909
50,000 input, 1,000 output$0.0075 + $0.0005 = $0.00862

So the trial easily covers a full feature test, a few dozen long-context runs, or a small batch evaluation. It will not cover load testing. If you want to check behaviour on your real prompts at volume, the minimum top-up is $20, and the credit never expires. Details are on the pricing page.

Questions and answers

Do I need a card to claim the trial?

No. Sign up with Google or email and password, then claim the $0.50 with one click on the API key page.

What happens after 7 days?

Unused trial credit expires. Your account stays, and you can top up any whole amount from $20 to $500 to keep going.

Can I claim the trial more than once?

No, it is one per person.

Does a failed request use up trial credit?

No. Failed or refused requests are not charged.

Your key is one form away

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