Pokee-Isaac API

The base URL for this environment is https://api.pokee.ai/v1. The API serves only the documented /v1 endpoints; unknown routes return an OpenAI-shaped 404 error.

1. 1

   Create a key

   Sign in, create a key, and copy it immediately. The full key is shown only once.

2. 2

   Store it securely

   Put the key in a server-side secret or environment variable. Do not ship it in browser or mobile code.

3. 3

   Make a request

   Point an OpenAI-compatible client at the Pokee base URL and use model pokee-isaac.

curl https://api.pokee.ai/v1/chat/completions \
  -H "Authorization: Bearer $POKEE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "pokee-isaac",
    "messages": [
      {"role": "user", "content": "Explain why the sky is blue."}
    ]
  }'

By using api.pokee.ai, you agree to Pokee's Terms of Service and Privacy Policy.

Send your Pokee key as a Bearer token on every API request:

Authorization: Bearer pk-...

Pokee uses the OpenAI Chat Completions request and response format, so you can use the official OpenAI SDK or any compatible client. Requests are sent to Pokee, not OpenAI, through the configured base_url and use the pokee-isaac model.

Send an OpenAI-compatible chat-completion body to POST /v1/chat/completions. The fields below are supported along with other compatible chat-completion options.

Set stream: true to receive standard OpenAI-compatible chat-completion chunks over Server-Sent Events. Pokee includes a final chunk with token usage, and the stream ends with data: [DONE].

from openai import OpenAI

client = OpenAI(
    api_key="pk-...",
    base_url="https://api.pokee.ai/v1",
)

stream = client.chat.completions.create(
    model="pokee-isaac",
    messages=[{"role": "user", "content": "Write a short launch plan."}],
    stream=True,
)

for chunk in stream:
    content = chunk.choices[0].delta.content if chunk.choices else None
    if content:
        print(content, end="", flush=True)

curl -N https://api.pokee.ai/v1/chat/completions \
  -H "Authorization: Bearer $POKEE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  --data-binary @large-request.json

A normal streamed request ends if the caller disconnects. Use background mode when the result must remain available after a disconnect.

Pokee-Isaac accepts prompts up to roughly 10 million tokens, with a request body limit of 45 MiB. A prompt that large can take several minutes to serve — around seven minutes at 10 million tokens.

Token counts are reported in the usage object as measured by the model, and are what you are billed on. Bytes are a poor proxy for tokens — the same 1 MB of text can be anywhere from 140,000 to 700,000 tokens depending on its content — so size your requests against reported usage rather than body size.

Add background: true to a chat-completion request. This is a Pokee extension to Chat Completions, not an implementation of the OpenAI Responses API.

curl https://api.pokee.ai/v1/chat/completions \
  -H "Authorization: Bearer $POKEE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: report-2026-07-16" \
  -d '{
    "model": "pokee-isaac",
    "messages": [
      {"role": "user", "content": "Produce a detailed market analysis."}
    ],
    "background": true
  }'

# Poll
curl https://api.pokee.ai/v1/chat/completions/chatcmpl-... \
  -H "Authorization: Bearer $POKEE_API_KEY"

# Resume a stream after sequence 42
curl "https://api.pokee.ai/v1/chat/completions/chatcmpl-...?stream=true&starting_after=42" \
  -H "Authorization: Bearer $POKEE_API_KEY"

# Cancel
curl -X POST https://api.pokee.ai/v1/chat/completions/chatcmpl-.../cancel \
  -H "Authorization: Bearer $POKEE_API_KEY"

• Status values are in_progress, completed, failed, and cancelled.
• Background stream chunks include a stable response ID and sequence_number. SSE id: values use the same sequence.
• starting_after takes precedence over the Last-Event-ID header.
• A background generation can run for up to 10 minutes. Terminal resources are retained for approximately 10 minutes, then return 404.
• Only a background completion created with stream: true can be resumed with ?stream=true; other responses return 400 not_streamable. Polling works for both.

Send an Idempotency-Key header when retrying a request must not start a second generation or create a second charge. Use a unique printable value of at most 200 characters for each logical operation.

Idempotency-Key: customer-report-2026-07-16

• Reusing a key with a different request body returns 422 idempotency_key_reused.
• A duplicate synchronous request that cannot replay its response returns 409 idempotency_key_replayed.
• A duplicate background request may return the original background resource while it remains available.

Limits apply per developer account across all of its API keys. Every account gets 500 requests per minute and 20 million tokens per minute. Purchasing any credit package raises concurrent requests from 10 to 25.

Limits apply per developer account across all API keys. Any credit-package purchase unlocks paid concurrency; package size does not change the limit.

Error responses use one consistent OpenAI-compatible envelope:

{
  "error": {
    "message": "Insufficient available credits: 143 available, 156 required (156 reserved by in-flight requests)",
    "type": "insufficient_quota",
    "code": "insufficient_credits"
  }
}

400 responses share the invalid_request_error type; the code field, when present, narrows the cause (for example model_not_found or invalid_max_tokens).

On 429, wait for the number of seconds in the Retry-After response header before retrying. See Rate limits for the current policy.

• Usage is billed in whole credits. A non-zero charge below one credit rounds up to one credit; a request with no measured token usage costs zero credits.
• The request body limit is 45 MiB, which is roughly 10 million input tokens. Output defaults to 60,000 tokens and is capped at the same figure. Bodies over 16 MiB requirestream: true and Accept: text/event-stream.
• Available credits equal settled balance minus active reservations. The Billing and Dashboard pages show reserved and total credits when requests are in flight.
• View per-request input tokens, output tokens, credits, model, and API key on the Usage page.

Pokee does not persist inference prompts in its own application storage. The inference service emits operational logs containing only a ~120-character truncated preview of each message (not full prompt bodies); these logs are retained 1 day by our infrastructure provider and then automatically deleted. Separately, the provider stores the raw request payload encrypted at rest for up to 7 days for operational purposes before automatic deletion. No prompt data is used for training.

• What we do retain: request metadata only — token counts, timestamps, model, credits, API key id, and the caller IP for rate limiting. Never message content.
• Background responses are available for poll/resume/cancel, then deleted approximately 10 minutes after completion.

Full details are in our Privacy Policy and Terms of Service.