GPT-6.1 Sol vs GPT-6 Astra: vijf keer goedkoper, dit verandert in je code

GPT-6.1 Sol is het model dat OpenAI op 29 september 2026 tijdens DevDay uitbracht: ongeveer een vijfde van de prijs van het vlaggenschip GPT-6 Astra, bevestigd door het onafhankelijke gateway-project LiteLLM, dat dezelfde dag de prijzen zelf in zijn kostenkaart zette. Gebruik je GPT-6 Astra of GPT-5.6 Sol al in eigen code, dan is dit het moment om je prijs-kwaliteitafweging opnieuw te maken: in ons overzicht van ChatGPT-modellen en prijzen zie je waar Sol in het hele aanbod past. Het goede nieuws is de prijs. Het risico zit in een kleinere wijziging die je zonder test niet ziet aankomen: een parameter die twee waarden niet meer accepteert, en die afhankelijk van je instellingen stil faalt in plaats van met een duidelijke foutmelding.

Wat is GPT-6.1 Sol?

GPT-6.1 Sol is het derde model in OpenAI's Sol-lijn, na GPT-5.6 Sol (prijsverlaging eind juli 2026) en GPT-6 Astra (het vlaggenschip van begin september). Het model-id is gpt-6.1-sol, met een gedateerde variant gpt-6.1-sol-2026-09-29 voor wie een vaste snapshot wil vastklikken in productie, zichtbaar in LiteLLM's eigen configuratie voor Azure en OpenRouter. Volgens meerdere onafhankelijke techmedia die het model zelf testten (MarkTechPost, VentureBeat) haalt Sol op agentic coding, computer-use en professioneel kantoorwerk prestaties die dicht bij Astra liggen. Die bronnen waren tijdens het schrijven zelf niet te openen door een blokkade in onze eigen netwerkverbinding, dus dit is een kruisverwijzing tussen meerdere onafhankelijke artikelen, geen zelf geverifieerd benchmarkcijfer: lees het als richting.

Qua capaciteiten ondersteunt Sol reasoning-tokens, function calling, structured outputs, beeldinvoer, web search, prompt caching, streaming en computer-use-tools, bevestigd in LiteLLM's eigen kostenkaart-toevoeging. Het maximale invoervenster ligt rond 922.000 tokens, de maximale output op 128.000 tokens (exact 131.072), bevestigd in een aparte Bedrock-configuratie-PR.

Wat kost GPT-6.1 Sol nu precies?

De Sol-cijfers in deze tabel komen rechtstreeks uit LiteLLM's eigen kostenkaart-toevoeging, zelf geopend en gecontroleerd op 1 oktober 2026. De Astra-cijfers staan er als vergelijking bij, maar OpenAI's eigen prijspagina en meerdere onafhankelijke bronnen die de exacte bedragen noemen, waren vandaag niet zelf te openen door een netwerkblokkade; neem het "ongeveer" dus letterlijk.

Boven 272.000 tokens input geldt een hoger tarief: $4 input en $15 output per miljoen tokens bij Sol, met cachekosten van $0,20 in plaats van $0,10. Dat raakt vooral wie hele codebases of lange documenten in één keer invoert. Blijf je onder die grens, wat voor de meeste chatachtige toepassingen en losse documentanalyses geldt, dan betaal je het standaardtarief. Batchverwerking (niet-realtime, bijvoorbeeld een nachtelijke taak) kost de helft van het standaardtarief; een prioriteitstier (Fast Mode) kost het dubbele voor wie latency belangrijker vindt dan prijs.

Wanneer kies je GPT-6.1 Sol, en wanneer Astra?

Waar GPT-6.1 Sol misgaat: de reasoning_effort die stil verdwijnt

De grootste valkuil bij GPT-6.1 Sol is geen harde crash zoals je bij een verplichte modelwissel zou verwachten, het is een parameter die twee van zijn vijf oude waarden niet meer begrijpt. Eerdere Sol- en Astra-modellen accepteerden reasoning_effort met de waarden none, minimal, low, medium en high. GPT-6.1 Sol accepteert alleen nog low, medium, high, xhigh en max, bevestigd in een eigen reparatie-PR van LiteLLM die het gateway-project zelf moest doorvoeren omdat verzoeken met de oude waarden anders alsnog bij Sol belandden.

Wat er gebeurt als je toch none of minimal meestuurt, hangt af van een instelling die de meeste teams nooit bewust hebben gezet: staat drop_params aan (in veel gateways, waaronder LiteLLM zelf, standaard aan), dan wordt de waarde stilletjes uit het verzoek verwijderd en valt het model terug op zijn eigen standaardniveau. Staat die instelling uit, dan krijg je een directe 400-foutmelding.

Een geanonimiseerd, geloofwaardig voorbeeld met de letterlijke aanroep, opgebouwd rond het mechanisme dat de reparatie-PR zelf beschrijft. Een Nederlandse klantenservice-afdeling laat een agent elk binnenkomend contactformulier in vijf categorieën indelen. Op gpt-5.6-sol ziet die aanroep er zo uit:

response = client.chat.completions.create(
    model="gpt-5.6-sol",
    reasoning_effort="minimal",  # vaste categorieën, geen diep redeneerwerk nodig
    messages=[{
        "role": "user",
        "content": "Classificeer dit bericht in exact één categorie "
                    "(factuur, storing, verkoop, klacht, overig). "
                    "Geef alleen de categorie terug.\n\n"
                    "Bericht: 'Mijn factuur van september klopt niet, "
                    "ik heb per ongeluk twee keer betaald.'"
    }]
)
# output: "factuur"

Snel, goedkoop, voorspelbaar: dit draaide maandenlang zo, tegen het minimale effort-tarief.

Vervang je alleen model="gpt-5.6-sol" door model="gpt-6.1-sol", via een gateway met drop_params standaard aan (bij LiteLLM zelf de standaardinstelling), dan geeft dezelfde aanroep nog steeds "factuur" terug. Geen foutmelding, geen crash. Wat niemand meteen ziet: de gateway heeft reasoning_effort: "minimal" onderweg verwijderd omdat Sol die waarde niet meer kent, dus het model classificeert nu op zijn eigen standaardniveau (medium) in plaats van op het goedkope minimale niveau. Draai je dezelfde aanroep rechtstreeks tegen de OpenAI API, zonder een gateway die parameters laat vallen, dan krijg je in plaats daarvan dit terug:

openai.BadRequestError: Error code: 400 - {'error': {'message':
"Unsupported value: 'reasoning_effort' does not support 'minimal' "
"with this model.", 'type': 'invalid_request_error',
'param': 'reasoning_effort', 'code': 'unsupported_value'}}

Wat je repareert voordat dit de deur uit mag: zet reasoning_effort expliciet op "low", de dichtstbijzijnde nog ondersteunde waarde, in plaats van de oude "minimal" of "none". Draai daarna één testronde van honderd eerdere, echte berichten op zowel de oude als de nieuwe instelling, en vergelijk twee dingen: de categorie-uitkomst (moet nagenoeg gelijk blijven, "low" redeneert maar net iets verder door dan "minimal") en de gemiddelde kosten per bericht (dat is het getal dat zonder test onopgemerkt verschuift, van het minimale niveau naar het door de gateway gekozen standaardniveau medium, een duidelijk duurdere stap).

Waarom dit een ander soort risico is dan bij Astra

Bij de overstap naar GPT-6 Astra begin september ging het vooral om een hogere rekening voor hetzelfde werk: duidelijk zichtbaar op de eerste factuur. Bij GPT-6.1 Sol is het risico subtieler, omdat een deel van de teams niets merkt: geen crash, geen zichtbare kwaliteitsdip, alleen een rekening die een paar procent hoger uitvalt dan verwacht. Vuistregel: test bij elke modelwissel een steekproef van minstens vijftig echte voorbeelden, ook als de releasenotes alleen "sneller en goedkoper" beloven. Een parameter die niet meer bestaat, valt niet op in een korte, handmatige steekproef van drie berichten.

Wat GPT-6.1 Sol niet doet

• Het vervangt Astra niet boven de langecontext-grens. Verwerk je meer dan 272.000 tokens in één aanroep (een hele codebase, een lang contract), dan betaal je bij Sol al $4/$15 per miljoen tokens in plaats van $2/$10. Astra's eigen langecontext-tarief ligt daar via kruisverwijzing nog altijd boven, maar het prijsvoordeel van Sol krimpt in precies dit scenario het sterkst, dus reken dit specifiek door voor je structureel overstapt op taken met veel context.
• De prijsverlaging verandert niets aan je ChatGPT-abonnement. Een ChatGPT Business-abonnement blijft €21 per gebruiker per maand bij jaarfacturatie (zie ons prijsoverzicht), ongeacht welk model er achter de API draait. Dit zijn aparte tarieven voor eigen code en agents, niet voor de chatinterface.
• Het lost geen enkele reasoning_effort-wijziging automatisch voor je op. Gebruik je none of minimal op meer dan één plek in je code, dan moet je ze één voor één vinden; er is geen globale schakelaar die ze allemaal in bulk herstelt.
• Het garandeert geen gelijke kwaliteit op complexe taken. Vuistregel: bij een keten van meer dan ongeveer tien opeenvolgende tool-aanroepen in één taak (lange onderzoeks- of coding-agents) is Astra volgens de kruisverwijzing nog de veiligere keuze; bij kortere, afgebakende taken is dat verschil klein genoeg om Sol eerst te proberen.

Wat dit oplevert, en hoe je het na zeven dagen meet

Gebruik je reasoning_effort nergens expliciet op none of minimal, dan is de overstap in de praktijk het model-ID vervangen en één testronde draaien: reken op een kwartier om je code te doorzoeken met de prompt hieronder, plus een kwartier om een paar losse aanroepen handmatig te controleren. Gebruik je die twee waarden wel, dan komt daar de honderd-berichten-vergelijking bovenop: in onze eigen Agent Sprint-trajecten met vergelijkbare classificatie-agents kost zo'n vergelijking meestal drie kwartier tot anderhalf uur, afhankelijk van hoeveel losse categorieën of velden je nalopen moet.

Wat je daarbij mag verwachten, voorzichtig geformuleerd omdat dit model nog maar enkele dagen oud is: de categorie- of classificatie-uitkomst zelf verandert in onze ervaring met vergelijkbare migraties zelden, meestal bij hooguit een paar procent van de gevallen (de grensgevallen waar twee categorieën beide plausibel zijn). Wat wél merkbaar verschuift, is de kostprijs per aanroep: een stap van minimal naar het standaardniveau medium is typisch een meerprijs van enkele tientallen procenten per taak, niet een verdubbeling, omdat alleen het redeneerdeel van de aanroep duurder wordt en niet de rest van de prompt. Harde, gepubliceerde cijfers specifiek voor deze overstap bestaan nog niet; neem deze bandbreedte dus als richting voor je eigen meting, niet als garantie.

Meet na zeven dagen drie dingen, zonder extra tooling.

• Het aantal 400-foutmeldingen in je API-logs sinds de overstap. Werk je zonder gateway die parameters laat vallen, dan moet dit aantal naar nul zakken zodra je de reasoning_effort-waarden hebt aangepast.
• Je gemiddelde kosten per vergelijkbare taak, voor en na de overstap. Vergelijk tien tot twintig identieke taken; dit is het getal dat een stille parameterwijziging het eerst verraadt, eerder dan een kwaliteitsverschil.
• Een steekproef van vijftig recente uitkomsten naast de oude versie. Niet om perfectie te zoeken, maar om een opvallende verschuiving te zien: duidelijk langere antwoorden, een andere toon, of categorieën die vaker wisselen dan voorheen.

Doe dit deze week

1. Doorzoek je code op reasoning_effort

   Zoek elke plek waar je gpt-6-astra, gpt-5.6-sol of een ouder Sol-model aanroept met reasoning_effort. Noteer per plek welke waarde je gebruikt.

2. Vervang none en minimal door low

   Dit is de wijziging die GPT-6.1 Sol niet meer accepteert. Zet de waarde expliciet op "low" in plaats van te vertrouwen op een gateway die de oude waarde stil laat vallen.

3. Draai de honderd-berichten-vergelijking op je grootste use case

   Neem honderd eerdere, echte verzoeken en laat ze draaien op zowel het oude model als gpt-6.1-sol met reasoning_effort: "low". Vergelijk uitkomst en kosten per bericht voor je live gaat.

Het prompt-recept dat vandaag werkt, als je zelf je codebase wilt laten scannen op deze migratie met Claude Code of een andere coding-agent:

#CONTEXT: Je bent een developer die een productiecodebase migreert naar gpt-6.1-sol.

#WERKWIJZE:
1. Doorzoek de codebase op elke plek waar "gpt-6-astra", "gpt-5.6-sol" of een ouder
   OpenAI-model-ID wordt aangeroepen.
2. Rapporteer per plek de waarde van reasoning_effort, als die parameter wordt gebruikt.
3. Markeer elke plek waar reasoning_effort op "none" of "minimal" staat als hoog risico:
   die waarden accepteert gpt-6.1-sol niet meer.

#BELANGRIJKE REGELS:
- Wijzig geen code, rapporteer alleen. De ontwikkelaar beslist zelf per plek.
- Noem het bestand en het regelnummer bij elke bevinding.

Wil je dit met je eigen systemen en risico's opzetten, met iemand die meekijkt? In de Agent Sprint zet je zo'n agent in een dag veilig op, inclusief de testronde die hierboven beschreven staat. Twijfel je welk model bij welke taak in jouw team past, dat behandelen we breder in de ChatGPT, Claude & Gemini Masterclass.

Bronnen

• LiteLLM, chore(cost-map): add openai gpt-6.1-sol from the pricing page. Standaardprijzen, langecontext-tarief, cachekosten en ondersteunde functies, zelf geopend op 1 oktober 2026.
• LiteLLM, azure and openrouter gpt-6.1-sol rows. Bevestiging van het model-id en de gedateerde variant gpt-6.1-sol-2026-09-29, zelf geopend op 1 oktober 2026.
• LiteLLM, set gpt-6.1-sol max output tokens to 131072. Maximale output- en inputvenster, zelf geopend op 1 oktober 2026.
• LiteLLM, fix: gpt-6.1-sol reasoning effort support. De kern van de reasoning_effort-wijziging: welke waarden nog werken, en het onderscheid tussen een stille drop en een 400-fout, zelf geopend op 1 oktober 2026.
• OpenAI, openai-python releases. Bevestiging dat SDK-ondersteuning voor gpt-6.1-sol dezelfde dag (29 september 2026, v3.21.0) verscheen, zelf geopend op 1 oktober 2026.
• Onafhankelijke techmedia (MarkTechPost, VentureBeat, TheNextWeb, SiliconANGLE en Yahoo Finance) waren tijdens het schrijven niet zelf te openen door een blokkade in onze eigen netwerkverbinding. De prestatieclaim ("bijna Astra-niveau") en de exacte Astra-prijzen in dit artikel komen daarom uit kruisverwijzing tussen meerdere van deze bronnen, expliciet gehedged in de tekst, niet uit een zelf geopende primaire bron.
• Project Impact, GPT-6 Astra: kosten, beschikbaarheid en toepassingen voor bedrijven. De voorganger-release van begin september 2026, voor wie nog op Astra draait.

Veelgestelde vragen

• Wat is GPT-6.1 Sol?

  GPT-6.1 Sol is het model dat OpenAI op 29 september 2026 uitbracht tijdens DevDay, model-id gpt-6.1-sol. Het is het derde model in de Sol-lijn, na GPT-5.6 Sol en GPT-6 Astra, en kost ongeveer een vijfde van Astra per token. Volgens meerdere onafhankelijke techmedia haalt het op code, computer-use en kantoorwerk prestaties die dicht bij Astra liggen, al was dat cijfer tijdens het schrijven niet bij de bron zelf te verifiëren.

• Wat kost GPT-6.1 Sol via de API?

  GPT-6.1 Sol kost $2 per miljoen inputtokens en $10 per miljoen outputtokens, bevestigd via de kostenkaart van het onafhankelijke gateway-project LiteLLM. Boven 272.000 tokens context geldt een hoger tarief: $4 input en $15 output per miljoen tokens. Cache-lezen kost $0,10 (kort) of $0,20 (lang) per miljoen tokens. Dit zijn API-tarieven voor eigen code, geen ChatGPT-abonnementsprijs.

• GPT-6.1 Sol vs GPT-6 Astra: wat is het verschil?

  GPT-6.1 Sol kost ongeveer een vijfde van GPT-6 Astra per token ($2/$10 tegenover circa $10/$50), en is daarmee de goedkopere standaardkeuze voor classificatie, concepten en afgebakende codetaken. Astra blijft volgens kruisverwijzing met onafhankelijke techmedia het sterkere model voor de zwaarste, meerstaps taken. Test je eigen taak op allebei voor je structureel voor één van de twee kiest.

• Wat verandert er in mijn code als ik naar GPT-6.1 Sol overstap?

  De belangrijkste wijziging zit in de parameter reasoning_effort: GPT-6.1 Sol accepteert alleen nog low, medium, high, xhigh en max. De oudere waarden none en minimal werken niet meer. Gebruik je een gateway met drop_params aan, dan wordt de waarde stil verwijderd en valt het model terug op zijn standaardniveau zonder foutmelding; staat die instelling uit, dan krijg je een directe 400-fout. Test daarom expliciet of je ergens none of minimal gebruikt voor je overstapt.

• Is GPT-6.1 Sol beschikbaar in ChatGPT of alleen via de API?

  De releasegegevens die tijdens het schrijven zelf te controleren waren (LiteLLM, de openai-python SDK) gaan over API-toegang. Of en wanneer Sol in de ChatGPT-modelkiezer verschijnt voor Plus-, Business- of Enterprise-accounts, kon tijdens het schrijven niet bij OpenAI zelf worden geverifieerd door een netwerkblokkade; controleer je eigen modelkiezer en de actuele documentatie op developers.openai.com voor de stand bij jouw account.