ShareAI
AI Prosumer
EN
Language
OpenAI

gpt-oss-120b

Get API key
openai/gpt-oss-120b

gpt-oss-120b is a model by OpenAI that accepts text and produces text. This catalog entry identifies openai/gpt-oss-120b. Its reviewed context window is 131,072 tokens; deployment limits can be lower.

Input → Output
Text Text
Input / Output · per 1M tokens
€0.13524 / €0.540958
Context window
131,072 tokens
Maximum output
131,072 tokens
License: open_source

From model to application

Quick Start

API reference

  1. Get your API key

    Create a key in the ShareAI Console, then save it as an environment variable on your server.

    Create API key
    Environment variable
    export SHAREAI_API_KEY="your-api-key"

  2. Choose your endpoint

    Send a POST request with your API key in the Authorization header.

    POSThttps://api.shareai.now/api/v1/chat/completions

    This tag’s endpoint has not been confirmed. Check the API reference and your Console before sending a request.

  3. Make your first request

    The examples use your selected tag and show its request format. Run them on your server to keep your API key private. Model availability and account access are checked when you send a request.

    cURL
    curl --fail-with-body --request POST 'https://api.shareai.now/api/v1/chat/completions' \
  --header "Authorization: Bearer ${SHAREAI_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data-raw '{
  "model": "openai/gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
}'
    Python
    import json
import os
import urllib.request

payload = {
    "model": "openai/gpt-oss-120b",
    "messages": [
        {
            "role": "user",
            "content": "Hello!",
        },
    ],
    "stream": False,
}
request = urllib.request.Request("https://api.shareai.now/api/v1/chat/completions",
    data=json.dumps(payload).encode(),
    headers={
        "Authorization": f"Bearer {os.environ['SHAREAI_API_KEY']}",
        "Content-Type": "application/json",
    },
    method="POST",
)
with urllib.request.urlopen(request, timeout=180) as response:
    print(json.dumps(json.load(response), indent=2))
    Go
    package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)

func main() {
    if err := run(); err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
}

func run() error {
    key := os.Getenv("SHAREAI_API_KEY")
    if key == "" { return fmt.Errorf("set SHAREAI_API_KEY") }
    body := []byte(`{
  "model": "openai/gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
}`)
    request, err := http.NewRequest(http.MethodPost, "https://api.shareai.now/api/v1/chat/completions", bytes.NewReader(body))
    if err != nil { return err }
    request.Header.Set("Authorization", "Bearer " + key)
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{Timeout: 180 * time.Second}
    response, err := client.Do(request)
    if err != nil { return err }
    defer response.Body.Close()
    if response.StatusCode < 200 || response.StatusCode >= 300 {
        detail, _ := io.ReadAll(io.LimitReader(response.Body, 1<<20))
        return fmt.Errorf("ShareAI HTTP %d: %s", response.StatusCode, detail)
    }
    var result any
    if err := json.NewDecoder(response.Body).Decode(&result); err != nil { return err }
    encoder := json.NewEncoder(os.Stdout)
    encoder.SetIndent("", "  ")
    return encoder.Encode(result)
}

    Save as main.go and run go run main.go. This example uses the Go standard library.

    Set up Rust dependencies

    In your Cargo project, add these dependencies. Save the example as src/main.rs, then run cargo run.

    Cargo commands
    cargo add [email protected] --no-default-features --features blocking,json,rustls-tls
cargo add serde_json@1
    Rust
    fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("SHAREAI_API_KEY")?;
    let payload: serde_json::Value = serde_json::from_str(r#"{
  "model": "openai/gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
}"#)?;
    let client = reqwest::blocking::Client::builder()
        .timeout(std::time::Duration::from_secs(180))
        .build()?;
    let response = client.post(r#"https://api.shareai.now/api/v1/chat/completions"#)
        .bearer_auth(api_key)
        .json(&payload)
        .send()?
        .error_for_status()?;
    let result: serde_json::Value = response.json()?;
    println!("{}", serde_json::to_string_pretty(&result)?);
    Ok(())
}
    TypeScript
    const payload = {
  "model": "openai/gpt-oss-120b",
  "messages": [
    {
      "role": "user",
      "content": "Hello!"
    }
  ],
  "stream": false
};
const response = await fetch("https://api.shareai.now/api/v1/chat/completions", {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.SHAREAI_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify(payload),
});
if (!response.ok) throw new Error(await response.text());
console.log(JSON.stringify(await response.json(), null, 2));

Pricing

EUR · per 1M tokens

ShareAI EUR

Input
All lengths€0.13524/M tokens
Output
All lengths€0.540958/M tokens
Cache read
All lengths€0.13524/M tokens
Cache write
All lengths€0.13524/M tokens

Cache read, Cache write follows the input rate. Cached tokens are counted once.

A little more detail

Frequently asked questions

What is gpt-oss-120b?

gpt-oss-120b is a model by OpenAI that accepts text and produces text. This catalog entry identifies openai/gpt-oss-120b. Its reviewed context window is 131,072 tokens; deployment limits can be lower.

How much does gpt-oss-120b cost?

Published ShareAI rates start at €0.13524 for input and €0.540958 for output per million tokens. Rates depend on the selected tag, pricing plan and token range. See Pricing above for cache rates and all published tiers.

What inputs and outputs does gpt-oss-120b support?

Inputs: Text. Outputs: Text. These capabilities apply to the selected model tag. Check the endpoint documentation for supported request formats.

What is the context length of gpt-oss-120b?

This tag has a context window of 131,072 tokens. Context size and pricing thresholds are separate. Request limits can be lower for a particular deployment. Maximum output: 131,072 tokens.

Does gpt-oss-120b support tool calling and structured outputs?

Tool calling: Supported. Structured outputs: Supported.

How do I use gpt-oss-120b with ShareAI?

Create an API key in the ShareAI Console, choose a model tag, and send an authenticated request to the endpoint in Quick Start. Your key must have access to the chosen model. Keep your key on your server.