console.upstage.ai

Sign up at console.upstage.ai with the Log in button in the upper right, create an API key on the API keys page, then send a chat completion request to https://api.upstage.ai/v1 using the OpenAI-compatible client and a current model name such as solar-pro4. New accounts receive $10 in free credit, which is enough to complete a first request and explore the example snippets before you decide on a paid billing path.

Before You Start

You need:

• A web browser to reach the console and sign up.
• Python (or Node.js, or just cURL) if you want to run the example snippets locally.
• A place to store the API key securely — treat it like a password. The console shows keys on the API keys page, so copy it once and keep it out of source control.

No infrastructure setup is required; the APIs are hosted.

Step 1: Create Your Account and Confirm Free Credit

1. Open console.upstage.ai.
2. Press Log in at the upper right of the page and complete sign-up.
3. After signing in, confirm the $10 free credit is attached to your account. This credit lets you make requests before adding a payment method.

If you plan to go beyond the free credit later, the console offers two paths under "Continue with paid usage" — see the billing section below.

Step 2: Create an API Key

1. On the console, click Create new key.
2. Copy the key immediately and store it in an environment variable, for example:

export UPSTAGE_API_KEY="your-key-here"

3. You can review and manage existing keys on the API keys page.

Expected result: you have a key string that starts working immediately for API calls.

Step 3: Make Your First Chat Request

Upstage exposes an OpenAI-compatible endpoint, so you can reuse the OpenAI SDK by pointing base_url at Upstage and passing your key.

from openai import OpenAI

client = OpenAI(
    api_key="UPSTAGE_API_KEY",   # replace with your key or read from env
    base_url="https://api.upstage.ai/v1"
)

response = client.chat.completions.create(
    model="solar-pro4",
    messages=[
        {"role": "user", "content": "An $80 item gets a 20% discount, then 10% tax is added. What is the final price? Answer with only the dollar amount."}
    ],
    reasoning_effort="medium"
)

message = response.choices[0].message
reasoning = getattr(message, "reasoning", None)
if reasoning:
    print(reasoning)
print(message.content)

What happens at each point:

• Input: your API key, the base URL, a model name, and a messages array.
• Action: the SDK sends a POST to the chat completions route under /v1.
• Expected result: a response object whose choices[0].message.content holds the answer. If the model returns reasoning content, it appears on the reasoning attribute.

The same snippet is available in cURL, JavaScript, LangChain, and LlamaIndex variants on the console's example code panel, so pick whichever fits your stack.

Step 4: Pick the Capability You Actually Need

Upstage groups its APIs by task. Choose based on your use case rather than defaulting to chat:

Each capability page includes a ready-to-use code snippet, so the setup pattern from Step 3 carries over — swap the endpoint and payload, keep the same key and base URL.

If you're building an AI agent or automated tooling, the machine-readable docs index at /llms.txt is the faster entry point than browsing pages.

Step 5: Decide How to Pay Before Free Credit Runs Out

The console offers two billing models:

• Pay-as-you-go: no credits to buy; your registered payment method is charged monthly for usage. Add a payment method from the billing page.
• Prepaid credits: buy credits in advance. Buying credits can also raise your rate limit, which matters if you hit throttling during testing.

For details, the console points to its billing FAQ. Check current pricing on the Upstage pricing page before committing, since rates and credit terms can change.

Common Setup Problems and Fixes

Privacy Note

Upstage states that it does not store or reuse any data sent to its APIs. If your documents are sensitive, review the linked terms before sending production data — this is the relevant condition to check rather than an assumption you should make.

A free hosted REST API like ReqRes gives you a real HTTP endpoint you can call immediately—no signup, no local server, no database setup. You get predictable JSON responses for users, resources, login, and registration, which makes it useful for front-end demos, integration tests, learning HTTP clients, and prototyping. What it is not is a production backend for your app: the data is shared, resets periodically, and you don't control the schema. If you need persistent, private data with auth and logs, that's where an account-based backend or a commercial licence comes in.

What "free REST API for testing and prototyping" actually means

The phrase sounds vague, so it helps to separate two things people often conflate:

• A mock/sample API — a public, hosted service with fixed or semi-fixed endpoints that return realistic-looking JSON. You don't own the data. It exists so you can point code at a URL and get a response.
• A real backend you configure — a service where you define collections, schemas, authentication, and logging, and where your data persists and belongs to you.

ReqRes's landing page describes both: a free REST API for testing and prototyping with real responses and no signup, plus an option to build your own backend with collections, auth, and logs at app.reqres.in. Those are different products with different trade-offs. The free public endpoints are the "point and go" part; the account-based backend is the "own your data" part.

What you can do with the no-signup public endpoints

1. Front-end demos without a backend

If you're building a UI and need data to render, you can fetch from a public endpoint instead of hardcoding arrays. This keeps your demo code closer to real fetch logic:

async function loadUsers(page = 1) {
  const res = await fetch(`https://reqres.in/api/users?page=${page}`);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const { data, total, page: current } = await res.json();
  return { users: data, total, page: current };
}

You get pagination fields, a data array, and support metadata—enough to build list views, loading states, and empty states.

2. Integration and contract tests

You can assert that your HTTP layer handles status codes, headers, and JSON shapes correctly. Typical checks:

• GET /api/users/2 returns 200 with a data object.
• GET /api/users/23 returns 404 (a non-existent user).
• POST /api/login with valid credentials returns a token; with missing fields returns 400.

This is useful for testing your client wrapper, retry logic, error handling, and serialization—without spinning up your own server.

3. Learning HTTP clients and tooling

If you're new to fetch, Axios, curl, Postman, or HTTPie, a hosted API is a low-friction target. You can practice:

• Sending query parameters (?page=2, ?delay=3).
• Setting headers and reading response headers.
• Handling POST, PUT, PATCH, DELETE.
• Observing status codes for success and failure.

4. Deliberate failure and latency testing

Endpoints that return 404 on purpose, or that accept a delay parameter, let you test how your app behaves when things go wrong or slow down. That's hard to do reliably against a happy-path local mock.

What the public endpoints are not good for

The key limitation: you don't own the data, and other people are hitting the same endpoints. Treat responses as illustrative, not authoritative.

When you'd move to an account-based backend

Consider app.reqres.in (collections, auth, logs) when any of these are true:

• You need your own collections and fields, not the fixed demo schema.
• You need data to persist between sessions and belong only to you.
• You need real authentication flows you can rely on in a demo or internal tool.
• You need request logs to debug what your client actually sent.
• You're working with a team and need shared, stable endpoints.

The trade-off is setup and, eventually, cost. The public endpoints require none; the backend requires an account and configuration.

Where pricing and licensing become relevant

The site signals a commercial licence and an upgrade path (with Stripe as the payment platform), but specific prices, plan tiers, and limits aren't stated here—so don't assume numbers. What you can reason about:

• Prototyping and learning → free public endpoints are usually enough.
• Internal tools, demos for clients, or anything you don't want reset → an account-based backend is the natural next step.
• Production or commercial use → check the licence terms and any paid plan, because "free for testing" and "free for commercial production" are not the same thing.

Before committing, read the current terms on the site rather than relying on secondhand summaries, since pricing and licence scope change.

A quick decision checklist

1. Do you need data that persists and is private? If yes → account-based backend.
2. Do you need a custom schema? If yes → account-based backend.
3. Are you only testing HTTP behavior, UI rendering, or learning a client? If yes → free public endpoints.
4. Will this touch real users or revenue? If yes → review the licence and any paid plan first.
5. Do you need logs and team access? If yes → account-based backend.

If you answer "no" to 1, 2, 4, and 5, the free hosted API is likely all you need. If you answer "yes" to any of them, plan for the account-based path.

Sign up at console.upstage.ai, claim the $10 in free credit, create an API key, and send your first request to the OpenAI-compatible endpoint at https://api.upstage.ai/v1 using the example code shown in the console. This path works if you want to test Upstage's models before committing to paid usage; once the free credit is used up, you choose between pay-as-you-go billing and prepaid credits.

Step 1: Create an account and claim the free credit

Press the Log in button at the upper right of the console page to sign up. New accounts receive $10 in free credit, which is enough to run initial experiments with the chat, document parsing, extraction, and embedding capabilities.

Step 2: Generate an API key

Click Create new key in the console. Your keys are listed on the API keys page, so you can return there to view or manage them later. Treat the key like a password — it authenticates every request you send.

Step 3: Make your first API request

Pick a capability from the menu and use the ready-to-use code snippet provided for it. The console offers examples in Python, LangChain, LlamaIndex, cURL, and JavaScript. The chat example below uses the OpenAI SDK pointed at Upstage's base URL:

from openai import OpenAI

client = OpenAI(
    api_key="UPSTAGE_API_KEY",
    base_url="https://api.upstage.ai/v1"
)

response = client.chat.completions.create(
    model="solar-pro4",
    messages=[
        {
            "role": "user",
            "content": "An $80 item gets a 20% discount, then 10% tax is added. What is the final price? Answer with only the dollar amount."
        }
    ],
    reasoning_effort="medium"
)

message = response.choices[0].message
reasoning = getattr(message, "reasoning", None)
if reasoning:
    print(reasoning)
print(message.content)

What each part does:

• base_url routes the OpenAI SDK to Upstage instead of OpenAI, so existing OpenAI-style code needs only the key and URL swapped.
• model="solar-pro4" selects the chat model.
• reasoning_effort="medium" controls how much reasoning the model applies; the response may include a separate reasoning field alongside the final answer.

Expected result: the script prints the model's reasoning (if returned) and then the final answer — for this prompt, the dollar amount.

Common snags:

• A 401 error usually means the API key is missing, mistyped, or not yet created.
• If you're building AI agents, the console points to a machine-readable docs index at /llms.txt for programmatic access to the documentation.

Step 4: Choose the capability that fits your task

Upstage groups its offerings by workflow. Match the capability to what you're building rather than defaulting to chat:

If your goal is a document QA service or extracting key information from documents, the document-focused capabilities are the intended starting point. On data privacy, Upstage states that it does not store or reuse any data sent to its APIs; the terms page has the details.

Step 5: Decide how to pay after the free credit

Two billing options are available, and the right one depends on your usage pattern:

• Pay-as-you-go — you pay after you use, with no need to buy credits. Upstage charges your registered payment method each month for your usage. Choose this if your volume is steady and you'd rather not manage a credit balance.
• Prepaid credits — you pay before you use by buying credits in advance. Buying credits can also raise your rate limit, which matters if you're hitting throughput ceilings during testing or launch. Choose this if you expect bursts of traffic or want predictable spend.

You can add a payment method or buy credits from the billing pages in the console. Current prices are listed on the pricing page; check it before committing to either option.

Quick checklist

1. Log in at console.upstage.ai and confirm the $10 credit.
2. Create an API key and note where to find it again.
3. Run the chat snippet with your key and base_url="https://api.upstage.ai/v1".
4. Switch to the capability matching your use case and reuse its snippet.
5. Pick pay-as-you-go or prepaid credits based on volume and rate-limit needs.