10 manieren om GPT-OSS 120B gratis te gebruiken

OpenAI heeft onlangs open‑weight‑modellen uitgebracht die zijn ontworpen voor krachtig redeneren, agentische taken en veelzijdige ontwikkelaarscases. Deze modellen zijn er in twee varianten: gpt-oss-120b en gpt-oss-20b. Het kleinere model kun je lokaal draaien op consumenten‑GPU’s, terwijl het draaien van gpt-oss-120b 80 GB VRAM en een robuustere computerconfiguratie vereist, waarover veel gebruikers niet beschikken.

Om te helpen heb ik een lijst samengesteld met gratis en eenvoudige manieren om toegang te krijgen tot het grotere model. Je kunt het model lokaal draaien met Ollama, Transformers of het vLLM‑framework. Er zijn ook gratis chatapps waarin je het model kunt testen, evenals tal van snelle en gratis inferenceproviders voor large language models (LLM) die je kunt uitproberen. Daarnaast kun je de LLM‑marktplaats bezoeken om de beste opties voor jouw use case te vinden. Bekijk ook onze aparte gids over hoe je GPT-OSS lokaal instelt en draait met Ollama. 

Open source

OpenAI GPT‑OSS is een open‑weight‑modelreeks die gebruikers toestaat het te downloaden en op elk systeem te draaien. Je kunt het ook lokaal gebruiken om applicaties te bouwen en projecten te maken. Dit model is beschikbaar voor zowel commercieel als open‑sourcegebruik.

In dit deel leren we het grote GPT‑OSS‑120B‑model draaien op consumentenhardware. 

1. Ollama 

Met Ollama heb je niet per se een GPU nodig; je kunt het model volledig op je CPU en RAM draaien. Zonder GPU‑versnelling zal de tokengeneratie echter aanzienlijk langzamer zijn. 

Als je meerdere GPU’s hebt, kun je enkele modellagen naar de GPU offloaden, wat de generatie aanzienlijk versnelt. Dit vereist wel wat technische kennis en configuratie om goed op te zetten.

Bron: gpt-oss

Om te beginnen installeer je Ollama op Linux.  

curl -fsSL https://ollama.com/install.sh | sh  Mogelijk gemaakt door

Voer daarna de volgende opdracht uit om het gpt-oss-120b‑model te downloaden en te draaien.  

ollama run gpt-oss:120bMogelijk gemaakt door

Zo eenvoudig is het.

2. Transformers

Met de Transformers‑bibliotheek kun je het model downloaden en laden, inference draaien, het model fine‑tunen en het direct integreren in je applicatie.

Voor modellen met 120 miljard parameters moet je modelsharding over meerdere GPU’s toepassen. Mogelijk moet je ook 8‑bit of 4‑bit‑kwantisatie gebruiken om het model in het geheugen te laten passen. 

Als je VRAM nog steeds onvoldoende is, kun je sommige lagen naar de CPU offloaden. Dit vergt meer ervaring en technische kennis, maar als je bekend bent met de stappen, is het te doen.

Bron: openai/gpt-oss-120b

Installeer de benodigde pakketten:

pip install -U transformers kernels torchMogelijk gemaakt door

Hier is een voorbeeld van gebruik: maak de tekstopwekkingspipeline, geef een prompt mee en voer de pipeline uit om een antwoord te genereren.

from transformers import pipeline
import torch

model_id = "openai/gpt-oss-120b"

pipe = pipeline(
    "text-generation",
    model=model_id,
    torch_dtype="auto",
    device_map="auto",
)

messages = [
    {"role": "user", "content": "What is the best DataCamp course to learn AI?"},
]

outputs = pipe(
    messages,
    max_new_tokens=256,
)
print(outputs[0]["generated_text"][-1])Mogelijk gemaakt door

3. vLLM

vLLM is een high‑performance inference‑engine die speciaal is ontworpen voor snelle tekstgeneratie met hoge doorvoer, ideaal voor productie‑omgevingen. 

Je kunt het op verschillende manieren inzetten: op je lokale server voor ontwikkeling en testen, in een private cloud voor intern gebruik, of bij kleine bedrijven en startups die meer controle en dataprivacy willen zonder afhankelijk te zijn van externe API’s.

Bron: GPT OSS - vLLM Recipes

Gebruik uv pip voor snellere installatie van Python‑pakketten. 

uv pip install --pre vllm==0.10.1+gptoss \
    --extra-index-url https://wheels.vllm.ai/gpt-oss/ \
    --extra-index-url https://download.pytorch.org/whl/nightly/cu128 \
    --index-strategy unsafe-best-matchMogelijk gemaakt door

Voer de volgende opdracht in je terminal uit om het model te downloaden en de vLLM‑server te starten:

vllm serve openai/gpt-oss-120bMogelijk gemaakt door

Zodra deze draait, start vLLM een lokale API‑server (standaard: http://localhost:8000) die je via HTTP‑verzoeken kunt bevragen en direct in je applicaties kunt integreren.

Chatapplicaties

AI‑chatapps laten je verschillende modellen uitproberen zonder enige setup. Het enige wat je hoeft te doen is naar de URL gaan en je aanmelden. Je kunt dan de functies van deze apps gebruiken.

In dit onderdeel bekijken we de officiële chat en de T3‑chatapp, die beide gratis toegang bieden tot de nieuwe OpenAI GPT‑OSS‑modellen.

4. GPT-OSS.com

Gpt-oss is de officiële website waar je beide open‑sourcemodellen van OpenAI kunt testen. De site is gemaakt in samenwerking met Hugging Face, dus je moet inloggen met je Hugging Face‑account om de volledige mogelijkheden van de modellen te ontgrendelen.

Bron: Gpt-oss

De app is volledig gratis met onbeperkte chatresultaten. Je kunt experimenteren met verschillende redeneerniveaus, tussen modi wisselen en zelfs vragen om vanaf nul een complete webapp te bouwen. Het is supersnel en vereist geen setup.

5. T3 Chat

Sinds ik T3 Chat ontdekte, ben ik er weg van. Het biedt razendsnelle toegang tot zowel open‑source‑ als propriëtaire modellen. Zie het als een ChatGPT‑achtige app, maar dan voor allerlei AI‑modellen, inclusief afbeeldingsgeneratie, vision‑language‑modellen en large language models.

Momenteel biedt T3 Chat gratis toegang tot zowel GPT‑OSS 20B als GPT‑OSS 120B. Je hoeft je alleen maar aan te melden en je kunt direct volledig functionele toegang tot deze modellen gebruiken.

Bron: t3.chat 

Het mooiste? De strakke, intuïtieve UI en de manier waarop je resultaten prachtig worden weergegeven.

LLM‑inferenceproviders

Inferenceproviders hosten large language models op hun eigen servers en geven gebruikers API‑ of webtoegang, zodat ze deze modellen direct in hun applicaties kunnen integreren zonder zelf een inferenceserver te hoeven draaien. Dit maakt het voor ontwikkelaars eenvoudig om krachtige modellen te gebruiken zonder zich zorgen te maken over deployment, schaalbaarheid of onderhoud.

In dit onderdeel bekijken we enkele supersnelle en gratis inferenceproviders die je nu meteen kunt gebruiken om toegang te krijgen tot de 120B‑variant van het GPT‑OSS‑model.

6. Cerebras

Cerebras is een van de snelste LLM‑inferenceproviders ter wereld, met tot 1.400 tokens per seconde bij gelijktijdige verzoeken. Dit maakt het een uitstekende keuze voor realtime AI‑systemen waar snelheid cruciaal is.

Er zijn echter een paar aandachtspunten:

• Prijs: Hoge request‑rates vereisen een betaald abonnement. De gratis laag biedt alleen basisgebruik.
• Nauwkeurigheid: Hoewel Cerebras extreem snel is, kan de outputkwaliteit variëren. Sommige inferenceproviders optimaliseren voor snelheid ten koste van precisie.

Bron: cerebras.ai

Cerebras is niet compatibel met de OpenAI‑SDK, dus je moet hun eigen SDK installeren:

pip install --upgrade cerebras_cloud_sdkMogelijk gemaakt door

Maak daarna de client met de API‑sleutel, maak de chatcompletion‑functie en genereer vervolgens de respons als stream.

import os
from cerebras.cloud.sdk import Cerebras

client = Cerebras(
    # This is the default and can be omitted
    api_key=os.environ.get("CEREBRAS_API_KEY")
)

stream = client.chat.completions.create(
    messages=[
        {
            "role": "system",
            "content": "Who was Leonardo Da Vinci?"
        }
    ],
    model="gpt-oss-120b",
    stream=True,
    max_completion_tokens=65536,
    temperature=1,
    top_p=1,
    reasoning_effort="high"
)

for chunk in stream:
  print(chunk.choices[0].delta.content or "", end="")Mogelijk gemaakt door

7. Groq

Ik ben groot fan van Groq omdat ze snelle en betaalbare inference‑endpoints bieden voor populaire open‑sourcemodellen. Op dit moment kun je de 120B‑variant van OpenAI’s GPT‑OSS gratis gebruiken, zij het met een beperkte request‑rate.

Je kunt het model direct proberen in Groq Studio voordat je het in je applicaties integreert, wat experimenteren en prompt‑tuning makkelijk maakt.

Bron: Groq

Groq is compatibel met OpenAI, wat betekent dat je de OpenAI Python‑SDK kunt gebruiken om hun modellen te benaderen. Groq biedt echter ook een eigen geoptimaliseerde SDK, beter afgestemd op hun infrastructuur, en die gebruiken we hier.

Installeer de Groq‑SDK:

pip install groqMogelijk gemaakt door

Maak de Groq‑client met de API‑sleutel en maak vervolgens de chatcompletions met de modelnaam en andere argumenten om de respons te streamen.

from groq import Groq

client = Groq(
    api_key=os.environ.get("GROQ_API_KEY"),
)

completion = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[
      {
        "role": "user",
        "content": "What is the meaning of life?"
      }
    ],
    temperature=1,
    max_completion_tokens=8192,
    top_p=1,
    reasoning_effort="medium",
    stream=True,
    stop=None
)

for chunk in completion:
    print(chunk.choices[0].delta.content or "", end="")Mogelijk gemaakt door

8. Baseten

Baseten is een krachtige inference‑ en trainingsplatform voor het deployen, schalen en beheren van AI‑modellen met volledige controle. Het mooiste is dat het qua tokengeneratiesnelheid kan meekomen met Groq en Cerebras.

Als je je aanmeldt, krijg je $5 aan deploymenttegoed en $1 voor API‑toegang. Dit tegoed kun je gebruiken om de diensten van het platform te benutten.

Bron: Model API | Baseten

Baseten is compatibel met OpenAI en heeft geen eigen SDK, dus we gebruiken de OpenAI Python‑SDK om het model‑endpoint te benaderen. Installeer daarvoor het OpenAI‑pakket voor Python:

pip install openaiMogelijk gemaakt door

Maak vervolgens de client met je API‑sleutel en base‑URL. Daarna kun je chatcompletions maken door de modelnaam en andere parameters op te geven. Tot slot kun je gestreamde responses genereren.

from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("BASETEN_API_KEY"),
    base_url="https://inference.baseten.co/v1"
)

response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[
        {
            "role": "user",
            "content": "Implement Hello World in Python"
        }
    ],
    stop=[],
    stream=True,
    stream_options={
        "include_usage": True,
        "continuous_usage_stats": True
    },
    top_p=1,
    max_tokens=1286,
    temperature=1,
    presence_penalty=0,
    frequency_penalty=0
)

for chunk in response:
    if chunk.choices and chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)
Mogelijk gemaakt door

LLM‑marktplaats

De LLM‑marktplaats geeft je toegang tot zowel open‑ als closed‑source large language models op één plek. Alle open‑sourcemodellen worden gehost op OpenRouter, zodat je een uniforme API kunt gebruiken zonder je zorgen te maken over kosten, beschikbaarheid of prestaties.

In dit onderdeel bespreken we twee van de populairste LLM‑marktplaatsen, OpenRouter en Requesty. Beide platforms bieden gratis toegang tot het GPT‑OSS 12B‑model.

9. OpenRouter

OpenRouter biedt een uniforme API die je via één endpoint toegang geeft tot honderden AI‑modellen. Het handelt automatisch fallbacks af en kiest de meest kosteneffectieve opties voor je verzoeken.

Je kunt met verschillende modellen experimenteren in hun LLM Playground, waarmee je outputs kunt testen en vergelijken voordat je ze in je workflow opneemt.

Bron: gpt-oss-120b

OpenRouter integreren is eenvoudig; pas simpelweg de base‑URL aan en geef je API‑sleutel op. De rest van de implementatie blijft hetzelfde als bij de OpenAI‑API.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.getenv("OPENROUTER_API_KEY"),
)

completion = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[{"role": "user", "content": "What is the meaning of life?"}],
)
print(completion.choices[0].message.content)Mogelijk gemaakt door

10. Requesty

Requesty lijkt op OpenRouter, maar routeert je verzoeken slim over 170+ AI‑modellen, waaronder GPT‑OSS 120B. Dit helpt je om:

• API‑kosten te verlagen
• SDK‑lock‑in te vermijden
• Toegang te krijgen tot geavanceerde functies zoals autocaching, loadbalancing en fallback‑beleid. 
• Een eenvoudige, met OpenAI compatibele interface te gebruiken

Je kunt modellen verkennen in het Chat‑menu, het klassement bekijken, je gebruiksdashboard inzien en directe integraties toevoegen.

Bij aanmelding krijg je $1 aan gratis tegoed, zodat je zelfs betaalde modellen kunt uitproberen.

Bron: Requesty

Om Requesty te integreren, werk je simpelweg de base‑URL, API‑sleutel en standaardheaders bij in je OpenAI Python‑SDK‑code.

Als je een gratis model wilt gebruiken, kies dan de modellen die door Groq worden aangeboden.

import os
import openai

ROUTER_API_KEY = os.getenv("REQUESTY_API_KEY")

client = openai.OpenAI(
    api_key=ROUTER_API_KEY,
    base_url="https://router.requesty.ai/v1",
    default_headers={"Authorization": f"Bearer {ROUTER_API_KEY}"},
)

# Example request
response = client.chat.completions.create(
    model="groq/openai/gpt-oss-120b",
    messages=[{"role": "user", "content": "Hello, who are you?"}],
)

# Print the result
print(response.choices[0].message.content)Mogelijk gemaakt door

Conclusie 

Na lang wachten heeft OpenAI eindelijk een open‑source LLM uitgebracht. Dat betekent dat je het nu kunt fine‑tunen, lokaal draaien en volledige controle hebt over de outputgeneratie. Jij hebt het voor het zeggen; je kunt er zelfs producten omheen bouwen zonder je data met OpenAI te delen of te betalen voor API‑toegang.

Dit is een grote stap vooruit voor AI, en in de loop der tijd zullen we nieuwe en verbeterde modellen zien die voortbouwen op de open‑sourcemodellen en frameworks van OpenAI. Wil je nu al gaan experimenteren, dan kun je:

• GPT‑OSS 120B lokaal draaien
• Er via je browser toegang toe krijgen met gratis chatapps
• Snelle en gratis LLM‑inferenceproviders proberen
• LLM‑marktplaatsen verkennen voor de beste en snelste modeltoegang

Begin je net aan je AI‑reis, bekijk dan zeker onze AI Fundamentals skill track met onderwerpen als LLM’s, ChatGPT, generatieve AI, AI‑ethiek en prompt engineering.