Key points
- Local you pay for hardware upfront and maintenance always; via API you pay only for tokens used.
- With $0.15 per 1M input tokens and $0.50 per 1M output tokens, $20 covers tens of millions of tokens.
- Local wins for continuous intensive use, offline work and total control over weights.
- API wins for those starting today, with little GPU or wanting an OpenAI-compatible endpoint.
The short answer
If you are looking for an uncensored LLM and do not already have a GPU with plenty of memory, the API is almost always the most sensible starting point. If instead you generate text all day, work offline or want to choose and modify weights, local deployment pays off the investment. Here is the comparison in a table.
| Aspect | Local | Via API |
|---|---|---|
| Initial cost | GPU, power supply, cooling | None, top up from $20 |
| Recurring cost | Electricity, wear and tear, your time | Only tokens used |
| Time to start | Hours or days between download and tests | A few minutes |
| Model choice | Free, you can keep many | Only one, chosen by the provider |
| Max context | Depends on your available memory | 100,000 tokens |
| Works offline | Yes | No |
| Parallel requests | As many as your GPU can handle | 8 with full key |
There is no absolute right choice. The sections below help you understand which side you are on.
What is really needed to run it at home
The bottleneck is video memory. Model weights must fit in VRAM, otherwise they fall back to system RAM and speed drops. As a rough order of magnitude, a small quantized 4-bit model typically takes a few gigabytes, while a very large one may require dozens. Exact values depend on the model and quantization, so always check the individual model card and tool documentation.
This adds context cache: the longer the conversation, the more memory it consumes beyond weights. A context of tens of thousands of tokens on a large model may require additional gigabytes.
The software
For local inference there are well-known tools like llama.cpp, Ollama and vLLM. Ollama and vLLM also expose an endpoint compatible with the OpenAI format, so the code you write today for a local server moves to a remote API by changing two lines. For installation details refer to the documentation of each project.
Finding the model
Open-weight models with fewer refusals are published by various communities, but quality is very uneven. Some lose coherence after modification, others respond well only with a precise prompt format. Expect to try several before finding one that fits.
How much does the API cost, with the math done
The rate is $0.15 per 1M input tokens and $0.50 per 1M output tokens, prepaid, no subscription. Failed or rejected requests are not charged and the credit never expires. Let's look at three scenarios.
- Light usage. 2M input tokens and 500,000 output tokens per month: 2 × $0.15 = $0.30 plus 0.5 × $0.50 = $0.25, total $0.55.
- Medium use. 50M input and 10M output: 50 × $0.15 = $7.50 plus 10 × $0.50 = $5.00, total $12.50.
- Heavy use. 400M input and 80M output: 400 × $0.15 = $60 plus 80 × $0.50 = $40, total $100.
The minimum top up is $20, so in the average case a single deposit covers more than a month. Above certain thresholds there is a bonus: +5% from $50, +10% from $100, +15% from $200. For example $100 becomes $110 in credit. The full price list is on the API pricing page.
For on-premise the calculation is less straightforward. Start with the GPU price, divide it by the months you plan to use it, and add electricity: power in kW multiplied by usage hours multiplied by your contract rate. Divide the result by the tokens you actually generate to get your cost per million. Plug in your numbers and compare with $0.50 per million output.
Maintenance that is usually forgotten
Choosing on-premise means handling everything else too. CUDA drivers and libraries breaking after an update, new inference engine versions, changing quantization formats, models to re-download. If the service serves other people, add monitoring, automatic restarts, and queue management when more requests arrive than the GPU can handle.
None of this is difficult, but it requires recurring time. If your time is worth something, factor it in: a few hours a month weigh more than the $12.50 from the average scenario above.
With the API, maintenance on your side is reduced to a key, a base URL, and handling 429 errors, described in the documentation. In exchange, you depend on the provider: if they have a problem, you cannot intervene.
When on-premise makes sense and when the API does
Choose on-premise if
- you already have a suitable GPU and the marginal cost is only electricity;
- you generate text continuously, for hours, every day;
- you need to work offline or with data that cannot leave your machine;
- you want to switch models often, fine-tune, or experiment with weights.
Choose the API if
- you want a working endpoint today, without buying anything;
- your usage is spiky: a bot, a nightly script, a prototype;
- you need a long context (100,000 tokens here) without sizing memory;
- you want to scale to 8 parallel requests without thinking about hardware.
Many teams use both approaches: the API to start and for spikes, on-premise for steady loads. Since the format is the same, switching from one to the other requires no application rewrite.
A simple method to decide
Before buying anything, measure. For a week, log how many tokens you consume, deriving them from the usage field in responses or your tool's counter. Then do three calculations.
- Multiply weekly input tokens by 4 and by $0.15 divided by one million.
- Do the same for output tokens at $0.50.
- Sum the two results and compare them with the monthly hardware installment plus electricity.
If the API sum stays below a few dozen dollars a month, buying a GPU for this rarely makes sense. If it exceeds the installment significantly, on-premise starts to become interesting. A separate case is latency: on your machine you do not cross the network, but a home GPU with a large model can be slower than a hosted service. Try both on your load, because differences depend on the model and prompt length.
Also keep in mind growth. A prototype that consumes little today can multiply when others use it. The API handles up to 8 simultaneous requests with the full key, while locally every additional user slows down everyone else until you add hardware.
Test the API in five minutes
To test, you need a key. After registering with Google or with email and password, on the key page you can request with one click $0.50 of trial credit, valid for 7 days and without needing to pay. Go to get your API key. The test key has a limit of 2 concurrent requests and 60 per minute.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.apiiasenzacensura.com/v1",
api_key=os.environ["API_KEY"],
)
risposta = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Spiega in tre frasi cos'è la quantizzazione di un modello."}],
)
print(risposta.choices[0].message.content)
If you later want to move to a local server with a compatible endpoint, just change base_url and the model name.
What it does not do
It is a single open-weight model, managed by an independent provider and trained to answer without content rejection for lawful adult use. It is not the official API of any major lab, does not generate images, audio or video and offers no embeddings or fine-tuning. An absolute limit remains: no sexual content involving minors. For a broader overview see the Uncensored AI page. Prompts are not used for training.

