Model APIs: Hosted vs Self-Hosted LLMs Explained

What a model API actually is

A model API hides a large neural network behind a plain HTTP request. You post a list of messages, the server runs the model on its own hardware, and you get the generated text back as JSON or as a stream. Your code never touches weights, drivers or CUDA. When people search for model apis, this is the contract they want: a stable URL, an authentication header and a predictable bill.

Two details decide how the endpoint feels in practice. The first is the wire format. Most tools today speak the OpenAI chat format, so an endpoint that copies it works with existing SDKs, frameworks and chat front ends. The second is the model behind the URL: its size, its context window and how it treats sensitive requests. The wire format is easy to compare. The model's behavior needs a real test.

A model API is also a billing relationship. You are renting inference time, measured in tokens, instead of owning a machine. That one change moves cost from a fixed monthly number to a figure that follows your traffic.

One more property shapes everything that follows: the API is stateless. The server keeps no memory of your conversation between calls. If you want the model to remember the last five messages, your code sends all five again with the next request. That is why token counts grow as a chat goes on, and why the way you manage history decides your bill.

Three ways to get answers from a model

There are three common setups, and each fits a different team.

The middle row is where this site sits. We host one open-weight model, run by an independent provider, and expose it through an OpenAI-compatible interface. It is not the official API of any model vendor and it does not route between vendors. If you need a particular vendor's model, go to that vendor. If you need an open model that answers without content refusals for lawful adult use, a hosted open-weight endpoint is the short path.

What self-hosting really costs

Running a model yourself looks free once the download finishes, which is why it attracts so many first projects. The cost shows up later, in three places.

Memory and hardware

A model has to fit in GPU memory along with its working cache for the prompt. Larger models and longer contexts need more of it, and the cache grows with every concurrent request. A setup that feels fast for one user can stall when ten people send messages at once.

Operations

Someone has to keep the server up, update the inference software, watch for out-of-memory crashes and decide what happens when the GPU is busy. That someone is usually you, at night, when a user reports a timeout.

Idle time

A GPU costs the same whether it answers one request an hour or one per second. Small apps with uneven traffic pay for a lot of idle silicon. Local tools such as Ollama are excellent for development and private experiments, and our article on common Ollama API mistakes covers the problems people hit when they point production code at them.

Reading a model API contract

Before you commit to any endpoint, collect five facts: the base URL, the model ID, how authentication works, which methods exist and what the limits are. For this service they are short.

• Base URL: https://api.modelapis.cc/v1
• Model ID: uncensored
• Auth: Authorization: Bearer YOUR_API_KEY
• Methods: POST /v1/chat/completions, POST /v1/responses, GET /v1/models
• Context: 100,000 tokens, prompt and completion together

With those in hand, a first call takes a few lines of the standard OpenAI Python SDK:

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.modelapis.cc/v1",
    api_key="YOUR_API_KEY",
)

reply = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Explain what a token is in two sentences."}],
)
print(reply.choices[0].message.content)
print(reply.usage)

The usage field is worth printing from day one. It tells you exactly how many input and output tokens the call used, which is the number your bill is built from. Full parameter notes are in the API documentation.

How pay-per-token pricing works

Billing has two meters. Input tokens are everything you send: the system prompt, the conversation history and the new message. Output tokens are what the model writes back. Here the rates are $0.15 per 1M input tokens and $0.50 per 1M output tokens, charged from prepaid credit with no subscription.

A worked example: a chat turn sends 2,000 input tokens and receives 500 output tokens.

• Input: 2,000 / 1,000,000 x $0.15 = $0.0003
• Output: 500 / 1,000,000 x $0.50 = $0.00025
• Total: $0.00055 per turn, or $0.55 per 1,000 turns

Failed or refused requests are not charged, and credit never expires, so a small balance does not decay while you build. The pricing page lists top-up amounts from $20 to $500 and the bonus tiers. Payment is in crypto only (USDT on TRC20 or USDC on Base).

If you want to compare with another provider, take their input and output prices from their own page and run the same two lines of arithmetic. Check their current pricing rather than relying on a number copied into an article, because list prices change.

Moving existing code to a hosted endpoint

If your app already talks to a local runtime or to another OpenAI-style service, switching is a configuration change, not a rewrite. Put the three variable parts in environment variables:

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.modelapis.cc/v1"),
    api_key=os.environ.get("LLM_API_KEY", "YOUR_API_KEY"),
)
MODEL = os.environ.get("LLM_MODEL", "uncensored")

reply = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "Ping"}],
)
print(reply.choices[0].message.content)

For local development with Ollama, which exposes an OpenAI-style route of its own, set LLM_BASE_URL to your local address and LLM_MODEL to the local model name. In production leave the defaults. The same code path runs in both places, which makes it easy to prototype offline and deploy against a hosted model without touching the logic.

After the switch, rerun your tests with real prompts. Output style, length and refusal behavior depend on the model, not on the protocol, so a passing integration test does not tell you the answers are what your product needs.

When a pay-per-token endpoint wins

Hosted per-token access usually beats a GPU of your own in four situations:

1. Uneven traffic. A side project, a Discord bot or a beta with a few dozen users spends money only when someone sends a message.
2. No ops capacity. If nobody on the team wants to babysit an inference server, renting is cheaper than the hours it saves.
3. Existing OpenAI code. Switching is a base URL and a key. You keep your SDK, your retry logic and your tests.
4. Prototype speed. You can test whether the model's behavior suits your product in an afternoon, before buying any hardware.

It loses when your load is constant and heavy enough to keep a GPU busy around the clock, when data may not leave your network, or when you need features this service does not offer. We are text only: no image, audio or video generation, no embeddings and no fine-tuning. For those, use a different tool next to this one.

Checklist before you pick one

1. Does it speak the OpenAI format, including streaming and tool calling, so your client code stays unchanged?
2. Is the model ID stable, and is it clear who runs the model?
3. What is the context window, and does the completion share it with the prompt?
4. What are the rate and concurrency limits, and what does the API return when you hit them?
5. Do you pay for failed requests?
6. How are prompts handled? Here they are not used for training.
7. How do you pay, and can you start small? A new account can claim $0.50 of trial credit with one click on the API key page, with no card needed.

Run a ten-minute test with your real prompts before deciding. Behavior on your own content tells you more than any feature list.

Privacy and keys

A hosted API means your prompts travel to someone else's server. That is the main thing you give up compared with running the model on your own machine, and it should be a conscious choice. Here prompts are not used for training. Even so, treat every request as data leaving your network: do not send secrets, private keys or other people's personal data unless you have a reason and the right to do so.

Keys deserve the same care. You can regenerate a key at any time from the API key page, and the old one stops working at once. Accounts that have topped up can hold up to 5 keys, label them and revoke any of them, so give each app or environment its own. If one leaks, you replace it in seconds and nothing else breaks.

More guides

• Which Model APIs Work With the OpenAI SDK?
• Ollama APIs: Common Mistakes and Fixes