Night Shift docs

Quickstart

1. Open the app and connect a wallet, or continue without one. You get a workspace and a Night Shift key that starts with ns_.
2. Burn $SHIFT on the Credits page. The API and the MCP server work once the workspace has credit.
3. Copy the key from the Get started panel.
4. Send a request with any OpenAI or Anthropic client. Use any model name; Night Shift picks the model and says which in the x-nightshift-model header.

from openai import OpenAI

client = OpenAI(base_url="https://nightshiftcode.com/v1", api_key="YOUR_NIGHTSHIFT_KEY")
reply = client.chat.completions.create(
    model="nightshift",
    messages=[{"role": "user", "content": "Hello from Night Shift"}],
)
print(reply.choices[0].message.content)

Keys and sign-in

Send the Night Shift key as Authorization: Bearer ns_... or as x-api-key: ns_.... Both work on every endpoint, so OpenAI and Anthropic clients need nothing special. Night Shift stores only a hash of each key and shows a key once, when it's made.

A workspace made with a wallet is linked to it. Signing in with that wallet again makes a new key for the same workspace, so a lost key never loses the workspace. A workspace made without a wallet depends on its key until you link one on the Credits page or from the Get started panel. Linking signs a one-time message and sends no transaction.

Make more keys, see when each was last used, and revoke them on the Keys page.

Connect your tools

Claude Code reads its address and key from environment variables. Leave ANTHROPIC_API_KEY empty so it uses the Night Shift key.

export ANTHROPIC_BASE_URL=https://nightshiftcode.com
export ANTHROPIC_AUTH_TOKEN=YOUR_NIGHTSHIFT_KEY
export ANTHROPIC_API_KEY=
claude

Anything that speaks chat completions takes Night Shift's address as its base URL: the OpenAI SDKs, Cursor, Continue, Aider, LangChain. Use https://nightshiftcode.com/v1 as the base URL, the Night Shift key as the API key and nightshift as the model. Anthropic SDKs take https://nightshiftcode.com as the base URL.

Codex uses OpenAI's Responses API, which Night Shift doesn't serve yet.

API reference

Replies come straight from the model that answered, in the format you asked in. Two headers say what happened: x-nightshift-model is the model that answered and x-nightshift-rung is its place on your ladder, 0 being the top. Request bodies can be up to 25 MB, and long streams are never cut off by Night Shift.

MCP server

Night Shift is also an MCP server, for agents that would rather call a tool than an API. Connect to https://nightshiftcode.com/mcp with the Night Shift key as a Bearer token, or to https://nightshiftcode.com/mcp/YOUR_NIGHTSHIFT_KEY for clients that can't set headers. Like the API, it needs credit from a burn.

claude mcp add --transport http nightshift https://nightshiftcode.com/mcp --header "Authorization: Bearer YOUR_NIGHTSHIFT_KEY"

Swarm

Swarm is for batches where each prompt is short and each answer is long: a hundred tickets to label, forty variants of a page to draft, a test to write for every function in a list. Instead of forty shift_ask calls in a row, your agent sends the whole list in one shift_swarm call and gets a swarm id back at once. Night Shift runs the jobs on its GPU 4 at a time, or 16 with Pro, while the agent carries on.

The agent collects the answers with shift_swarm_results, which waits up to 40 seconds for the swarm to finish and then returns the answers by index, in the order the prompts were sent. Long result sets come in pages; when next is a number, the agent asks again from there.

Each prompt has to carry everything the model needs, because the GPU can't see your files or the agent's conversation. Your agent writes every prompt as its own output, so pasting whole files into a swarm usually costs more than it saves. A swarm started while the GPU sleeps waits for it to wake, so a cold start no longer runs into the agent's tool timeout. If credit runs out, the jobs still waiting stop and nothing more is charged. A deploy in the middle of a swarm puts its running jobs back in the queue.

How routing works

Your ladder is your list of models from the top, the one you'd use for everything, down to the cheapest. You set it, a daily dollar budget for the top model, and the point at which Night Shift starts moving work down, on the Ladder page.

Night Shift grades each request by rules, not with another model: words like plan, migrate or refactor push it up, words like rename, summarise or format push it down, and attached tools add a little. While more than the start point of the budget is left, everything goes to the top model. Below it, the bar for staying on top rises as the budget runs down, and easier requests go to a model further down the list.

A conversation stays on the model it started on, because thinking blocks and prompt caches belong to one model. It only moves down when that model fails or is out. When a model rejects an option it doesn't support, Night Shift retries once without the newer options. A rate-limit error pauses that model until its retry time passes. If every model on the ladder fails, the request goes to the fallback model, Night Shift's GPU by default.

Night Shift's GPU

The GPU scales to zero when nobody is using it. The first request after a quiet spell starts a worker, which can take several minutes; Night Shift holds the request open until it's answered. Requests after that answer in about a second. Very long agent sessions can outgrow the 64K context; add your own models for those.

Credits and burns

Night Shift is paid for by burning $SHIFT, its token on Robinhood Chain. The API and the MCP server work while a workspace has credit, and answer 402 when it has none. Requests to Night Shift's GPU model draw the credit down at its token prices; requests routed to your own provider keys don't.

$SHIFT is the Robinhood Chain token (address posted at launch). Each million burned adds $5 of credit. The Credits page builds the burn for you: one transaction from your wallet that sends the tokens to the dead address 0x000000000000000000000000000000000000dEaD. Night Shift reads it back from the chain before adding credit, so a burn only counts for the wallet linked to the workspace, and only once.

Upgrades

Credit also buys more compute for your agents, on the Upgrades page. Buying more of an upgrade you already have extends it.

Your own models

Add provider keys on the Keys page. Night Shift checks each key with its provider before saving it, encrypted, and only uses it to call that provider for your requests.

When a model can be reached both directly and through OpenRouter, Night Shift uses the direct key.

Errors

Errors come back in the format of the request: an OpenAI error object for chat completions, an Anthropic error object for messages.

Privacy

Night Shift keeps the model, token counts, cost, timing and status of each request, and never the prompt or the reply. Provider keys are encrypted at rest. Prompts for Night Shift's GPU model run on GPUs Night Shift rents, and Night Shift doesn't store them; prompts for your own models go to those providers under your own agreements with them.