You do not need to download a checkpoint, configure an inference server, or reserve GPUs to add Qwen 3.8 27B Uncensored to an application. The hosted deployment on imageat’s Qwen 3.8 27B Uncensored model page exposes a familiar chat-completions interface, so an app that already uses an OpenAI-compatible client can usually adopt it by changing the base URL, API key, and model ID.
This tutorial shows the complete server-side setup: test a prompt, create a key, make the first request, use an OpenAI SDK, stream output, handle long context, choose settings, and troubleshoot common integration errors. It refers specifically to the current imageat-hosted deployment rather than making assumptions about every model that uses the Qwen name.
Integration facts at a glance
Use these values in your backend:
- Base URL:
https://api.imageat.com/v1 - Chat endpoint:
https://api.imageat.com/v1/chat/completions - Model ID:
qwen/qwen3.8-27b-uncensored - Authentication:
Authorization: Bearer YOUR_IMAGEAT_API_KEY - Request format: OpenAI-compatible role-based messages
- Context budget: up to 262,144 tokens shared by input and generated output
- Thinking mode: optional per request with
enable_thinking - Streaming: supported with
stream: trueusing OpenAI-style server-sent events - Model discovery:
GET /v1/models - Input and output: text messages in, one assistant response out
The word “uncensored” describes reduced refusal behavior. It does not guarantee that every response is safe, correct, legal, or suitable for publication. User-facing products still need moderation, rate limits, logging, abuse controls, and human review for consequential use cases.
1. Test your task in the playground
Before changing application code, run a representative prompt in the browser playground on the live Qwen model page. Start with a real task from your product rather than a generic question.
For a coding assistant, a useful test prompt is:
Review the following function for correctness, security, and maintainability. Return the three highest-priority issues, a revised implementation, and tests that fail before the fix and pass afterward. If information is missing, list your assumptions instead of inventing dependencies.
Run the task once with thinking disabled and once with thinking enabled. Compare correctness, format adherence, response time, and runtime cost. The point is not to find one universal preset; it is to establish a measured baseline for each route in your app.
2. Create an API key and keep it server-side
Create a key in imageat Projects. Keys use the iat_live_ prefix. Store the complete value in a server-side environment variable or secrets manager:
export IMAGEAT_API_KEY="your_server_side_key"
Never place a live key in browser JavaScript, a mobile bundle, a public repository, a screenshot, or a client-visible network request. If a web app needs Qwen, send the user’s request to your authenticated backend first. Your backend should validate the input, enforce quotas, call imageat, and return only the data the client needs.
3. Send your first chat completion
The fastest connectivity test is a cURL request:
curl https://api.imageat.com/v1/chat/completions \
-H "Authorization: Bearer $IMAGEAT_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen/qwen3.8-27b-uncensored",
"messages": [
{"role": "system", "content": "You are a precise coding assistant."},
{"role": "user", "content": "Explain why input validation belongs at an API boundary."}
],
"enable_thinking": false,
"temperature": 0.7,
"max_tokens": 600
}'
Read the user-facing answer from choices[0].message.content. When thinking mode is enabled, the response can also include a dedicated reasoning block. Design your UI around the final answer and do not expose internal reasoning by default.
4. Use the OpenAI Python SDK
Any OpenAI-compatible client needs three changes: point it at the imageat /v1 base URL, provide the imageat key, and send the exact imageat model ID.
Install the SDK in your project environment, then use:
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["IMAGEAT_API_KEY"],
base_url="https://api.imageat.com/v1",
)
response = client.chat.completions.create(
model="qwen/qwen3.8-27b-uncensored",
messages=[
{
"role": "system",
"content": "You are a concise software architecture assistant.",
},
{
"role": "user",
"content": "Propose a retry policy for a background job queue.",
},
],
temperature=0.7,
max_tokens=800,
extra_body={"enable_thinking": False},
)
print(response.choices[0].message.content)
extra_body passes the deployment-specific enable_thinking field without pretending it is a standard parameter in every OpenAI-compatible service. Keep timeouts and retry limits in your application layer. Do not retry every 4xx response automatically: authentication, malformed requests, and invalid model IDs require a fix, not another identical call.
5. Call the API from Node.js without exposing the key
A server route can use the platform’s standard fetch implementation:
const response = await fetch(
"https://api.imageat.com/v1/chat/completions",
{
method: "POST",
headers: {
Authorization: `Bearer ${process.env.IMAGEAT_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "qwen/qwen3.8-27b-uncensored",
messages: [
{ role: "system", content: "Return valid JSON only." },
{ role: "user", content: "Create three names for a note-taking app." },
],
enable_thinking: false,
temperature: 0.7,
max_tokens: 300,
}),
},
);
if (!response.ok) {
const detail = await response.text();
throw new Error(`Qwen request failed: ${response.status} ${detail}`);
}
const data = await response.json();
const answer = data.choices?.[0]?.message?.content;
Validate the response shape before using it. If the app expects JSON, parse it in a try block and validate the resulting object against your own schema. An instruction such as “Return valid JSON” improves the odds of structured output, but it is not a substitute for validation.
6. Add streaming responses
For chat interfaces, set stream: true. The endpoint returns OpenAI-style server-sent events, allowing the backend to forward text incrementally instead of waiting for the full completion.
A reliable streaming route should:
- Abort the upstream request if the user disconnects.
- Buffer incomplete event lines before parsing them.
- Stop cleanly at the stream’s completion marker.
- Enforce a total request timeout.
- Avoid logging full prompts or responses by default.
- Record status, latency, model ID, and a safe request identifier for debugging.
Streaming changes delivery, not model quality. Use it when faster perceived response matters; keep a non-streaming path for background jobs, evaluations, and workflows that need the complete response before the next step.
7. Verify the model ID instead of guessing
Model aliases can change across hosts. Query the discovery endpoint when configuring or diagnosing an integration:
curl https://api.imageat.com/v1/models \
-H "Authorization: Bearer $IMAGEAT_API_KEY"
Copy the accepted ID from that response. For the deployment documented here, the current ID is qwen/qwen3.8-27b-uncensored. Keep it in server-side configuration so you can update it without rebuilding a client application.
You can also inspect the broader imageat model library when a workflow needs a different text, image, or video model.
8. Choose thinking and sampling settings by task
The deployment supports enable_thinking, temperature, top_p, top_k, min_tokens, max_tokens, repetition_penalty, length_penalty, stop, seed, quantization, do_sample, user, and session_id.
For reasoning-heavy coding and planning, the model page recommends this starting point:
enable_thinking: truetemperature: 1.0top_p: 0.95top_k: 20repetition_penalty: 1.0
For direct answers and ordinary chat, start with:
enable_thinking: falsetemperature: 0.7top_p: 0.80top_k: 20repetition_penalty: 1.0
Treat these as baselines, not promises. Thinking mode can materially increase runtime and output length. Change one or two controls at a time, evaluate on saved test cases, and route easy tasks to direct mode instead of enabling deeper reasoning globally.
9. Manage the 262K context budget
The advertised 262,144-token context is shared by the conversation and generated output. If the input fills the budget, there is no room for a long answer.
For large documents or codebases:
- Reserve an explicit output allowance.
- Remove repeated navigation, headers, logs, and boilerplate.
- Label sources with stable names such as
FILE:,SECTION:, orREQUIREMENT:. - Put task instructions close to the evidence they govern.
- Ask the response to cite source labels or requirement IDs.
- Split unrelated tasks into separate calls.
- Recheck critical facts against the original source.
A large window is not perfect memory. For a very large corpus, retrieval is usually more efficient than sending everything on every turn. Select relevant passages first, then use the long context window to compare and synthesize them.
10. Budget for runtime-based API pricing
The live model page currently lists API-key requests at $0.00117 per second of model execution and notes that total cost varies with execution time. The page’s rounded header displays $0.0012 per second. Thinking-heavy or long requests can run longer, so measure completed-task cost in your own workload rather than estimating from prompt length alone.
The browser playground uses a separate website-credit flow: it temporarily reserves three credits, charges the usage tier reached after completion, and returns the unused reservation. Do not confuse those playground credits with the API’s per-second price.
Because pricing can change, verify the current figure on the Qwen model page before committing it to a customer-facing calculator or contract.
11. Connect Qwen to a content workflow
A useful pattern is to use Qwen as the planning layer and a specialized model as the production layer. For example:
- Send campaign requirements, source notes, audience constraints, and prohibited claims to Qwen.
- Ask for a structured creative brief, shot list, prompt set, and review checklist.
- Validate the brief with a human or deterministic rules.
- Send approved prompts to the imageat AI image generator or AI video generator.
- Store the source-to-output relationship so reviewers can trace each asset to its approved brief.
For agent-based clients, the approved plan can also feed an imageat MCP workflow. Keep API credentials separate by service, limit each tool’s permissions, and require confirmation before expensive or irreversible actions.
12. Add production safeguards
Reduced refusal makes application-level controls more important, not less.
Before launch:
- Authenticate users and apply per-user quotas.
- Moderate prompts and outputs according to the product’s risk profile.
- Reject oversized requests before sending them upstream.
- Redact credentials, private keys, and unnecessary personal data.
- Set connection, read, and total request timeouts.
- Retry only transient failures with capped exponential backoff and jitter.
- Log safe metadata rather than complete sensitive conversations.
- Detect automated probing and repeated abuse.
- Maintain a small regression set for correctness, format, safety, latency, and cost.
- Require human review for legal, medical, financial, security, or other consequential decisions.
Do not use the model to provide instructions that enable wrongdoing, violence, self-harm, illegal access, or other harmful activity. “Uncensored” is not a guarantee that the model will answer every prompt, and no model name guarantees factual accuracy.
Troubleshooting common integration errors
401 Unauthorized
Confirm that the request sends an active iat_live_ key as a Bearer token. Check for accidental spaces, a missing environment variable, or a revoked key. Do not print the complete key while debugging.
404 Not Found
Use https://api.imageat.com/v1 as the SDK base URL. The /v1 segment is required; https://api.imageat.com by itself is not the compatible API base.
Model not found
Call GET /v1/models and copy the current accepted model ID. Do not derive an ID from the marketing title.
The response is slow or too expensive
Disable thinking for direct tasks, reduce unnecessary context, set a realistic max_tokens, and ask for a bounded format. Measure whether a longer first answer actually prevents costly retries.
The response ignores part of a long document
Remove irrelevant material, label sources, state priorities explicitly, request source citations, and split unrelated questions. Context capacity does not guarantee uniform attention.
The app receives invalid JSON
Treat model output as untrusted text. Extract the intended JSON, parse it, validate it against a schema, and retry with corrective context only when the failure is recoverable.
FAQ
Is this a standard OpenAI API endpoint?
It is OpenAI-compatible, not an OpenAI-hosted model. Existing clients can use the imageat base URL, imageat key, and Qwen model ID while keeping the familiar chat-completions request shape.
Can I use the official OpenAI Python or JavaScript SDK?
Yes, if the client lets you set a custom base URL and pass deployment-specific fields. Keep https://api.imageat.com/v1 as the base and send the exact model ID returned by imageat.
Does the endpoint support streaming?
Yes. Set stream: true to receive OpenAI-style server-sent events.
Should thinking mode be enabled for every request?
No. Use it for difficult coding, planning, and multi-step analysis. Direct chat, extraction, classification, and short transformations often benefit from the lower latency of direct mode.
Does the endpoint accept images?
The current imageat documentation for this deployment describes text messages and does not expose possible vision inputs from the underlying checkpoint.
How much context can I send?
Messages and generated output share a maximum context budget of 262,144 tokens. Reserve room for the answer and avoid filling the window with irrelevant material.
How is the API billed?
The current model page lists $0.00117 per second of model execution for API-key requests. The browser playground separately reserves up to three website credits and settles the final usage tier after the run.
Where should I store the API key?
Use a server-side environment variable or secret manager. Never ship the key to a browser or mobile client.
Add the model to a real backend route
The practical path is straightforward: test one representative task in the playground, create a server-side key, verify the connection with cURL, switch your client to the imageat /v1 base URL, and evaluate direct and thinking modes on a saved test set. Add security, cost, and error controls before opening the route to users.