Reasoning

Enable reasoning tokens for enhanced model thinking with configurable effort levels across OpenAI, Anthropic, and Gemini

These tokens offer insight into the model’s reasoning process, providing a transparent view of its thought steps. Since Reasoning Tokens are considered output tokens, they are billed accordingly.

Get your API key in the Requesty Console.

To enable reasoning, specify reasoning_effort with one of the supported values in your API request.

​

Notes

• OpenAI does NOT share the actual reasoning tokens. You will not see them in the response.
• Deepseek reasoning models enable reasoning automatically, you don’t need to specify anything in the request to enable that.
• When using Deepseek and Anthropic, the reasoning content in the response will be under ‘reasoning_content’.

​

Reasoning effort values

Anthropic expects a specific number that sets the upper limit of thinking tokens. The limit must be less than the specified max tokens value.

OpenAI models expect one of the following ‘effort’ values, depending on the model:

• none
• low
• medium
• high
• xhigh
• max

See the “xhigh” and “max” effort section below.

Google Gemini expects a specific number when using Vertex AI, and supports OpenAI’s reasoning efforts via the Google AI Studio (their OpenAI-compatible API).

Requesty introduces new ‘effort’ values: ‘max’, ‘min’, and ‘none’ to support more granular control over reasoning.

​

”xhigh” and “max” effort

OpenAI has two effort levels above high: xhigh and, on the newest models, max. max is the highest. high, xhigh and max are three separate levels.

Requesty keeps a list of the effort levels each model supports. If the model supports the level you send, Requesty forwards it unchanged. For example, openai/gpt-6-luna, openai/gpt-6-sol and their Azure deployments (such as azure/gpt-6-luna@germanywestcentral) receive max as max, on both the global and the EU router. If the model does not support the level you send, Requesty sends the next higher level the model supports, or the next lower one if there is none higher. So max on a model whose highest level is xhigh is sent as xhigh.

xhigh and max are available on the /v1/chat/completions and /v1/responses endpoints. It is not reachable via the Anthropic-style /v1/messages endpoint, where OpenAI reasoning effort can only be controlled through thinking.budget_tokens (which maps to low/medium/high).

​

“none” or “min” effort

“none” or “min” are synonyms and work with all models. For reasoning models, it either disables reasoning or uses the minimal effort for it. So, for example, “none” or “min”, would use 128 with Gemini 2.5 Pro, or 0 with Gemini 2.5 Flash.

​

When using OpenAI via Requesty:

• If the client specifies a reasoning effort string (“none”, “low”, “medium”, “high”, “xhigh” or “max”) that the model supports, Requesty forwards the same value to OpenAI. For example, “max” reaches GPT-6 models as “max”.
• If the model does not support that effort, Requesty uses the closest level the model supports, as described in the “xhigh” and “max” effort section above.
• For models Requesty does not yet have a list of supported levels for, “max” is sent as “high”, “none” and “min” are sent as “low”, and the other levels are forwarded unchanged.
• If the client specifies a reasoning budget string (e.g. “10000”), Requesty converts it to an effort, based on the conversion table below.

Conversion table from budget to effort:

• 0-1024 -> “low”
• 1025-8192 -> “medium”
• 8193 or higher -> “high”

​

When using Anthropic via Requesty:

• If the client specifies a reasoning effort string (“low”/“medium”/“high”/“max”, “min”, or “none”), Requesty converts it to a budget, based on the conversion table below.
• If the client specifies a reasoning budget string (e.g. “10000”), Requesty passes this value to Google. If the budget is larger than the model’s maximum output tokens, it will automatically be reduced to stay within that token limit.

Conversion table from effort to budget:

• “min” / “none” / “low” -> 1024
• “medium” -> 8192
• “high” -> 16384
• “max” -> max output tokens for model minus 1 (i.e. 63999 for Sonnet 3.7 or 4, 31999 for Opus 4)

​

When using Vertex AI via Requesty:

• If the client specifies a reasoning effort string (“low”/“medium”/“high”/“max”, “min”, or “none”), Requesty converts it to a budget, based on the conversion table below.
• If the client specifies a reasoning budget string (e.g. “10000”), Requesty passes this value to Google. If the budget is larger than the model’s maximum output tokens, it will automatically be reduced to stay within that token limit.

Conversion table from effort to budget:

• “min” / “none” -> 0 for Gemini Flash and Flash lite, 128 for Gemini Pro models
• “low” -> 1024
• “medium” -> 8192
• “high” -> 24576
• “max” -> max output tokens for model

This conversion table is compatible with the Google AI Studio documentation.

​

When using Google AI Studio via Requesty:

Same as using OpenAI. See above.

​

Reasoning code example

For both tests, you can use either an OpenAI, Anthropic or Gemini reasoning model, for example:

• “openai/gpt-6-sol”
• “anthropic/claude-sonnet-5-5”
• “vertex/gemini-3.1-pro-preview”

​

Javascript example using reasoning effort

import OpenAI from 'openai';

const requesty_api_key = "YOUR_REQUESTY_API_KEY"  // Safely load your API key

const client = new OpenAI({
    apiKey: requesty_api_key,
    baseURL: 'https://router.requesty.ai/v1',
});

async function testReasoningEffort() {
    try {
        const prompt = `
            Write a bash script that takes a matrix represented as a string with
            format '[1,2],[3,4],[5,6]' and prints the transpose in the same format.
        `.trim();

        console.log('Sending request to reasoning model...');

        const completion = await client.chat.completions.create({
            model: "openai/gpt-6-sol",
            reasoning_effort: "medium",
            messages: [
                {
                    role: "user",
                    content: prompt
                }
            ]
        });

        console.log('\nCompletion Response:');
        console.log('-------------------');
        if (completion.choices[0]?.message?.content) {
            console.log(completion.choices[0].message.content);
        }

        console.log('\nToken Usage Details:');
        console.log('-------------------');
        if (completion.usage) {
            const usageDetails = {
                prompt_tokens: completion.usage.prompt_tokens,
                completion_tokens: completion.usage.completion_tokens,
                total_tokens: completion.usage.total_tokens
            };
            console.log(JSON.stringify(usageDetails, null, 2));

            // Log specific reasoning token details if available
            if ('completion_tokens_details' in completion.usage) {
                console.log('\nReasoning Token Details:');
                console.log('----------------------');
                console.log(JSON.stringify(completion.usage.completion_tokens_details, null, 2));
            }
        }

    } catch (error) {
        console.error('Error:', error);
    }
}

testReasoningEffort();

​

Python example using reasoning budget

import json
import openai

# Safely load your API key
requesty_api_key = "YOUR_REQUESTY_API_KEY"

client = openai.OpenAI(
    api_key=requesty_api_key,
    base_url='https://router.requesty.ai/v1'
)

def test_reasoning_budget():
    try:
        prompt = """
            Write a bash script that takes a matrix represented as a string with
            format '[1,2],[3,4],[5,6]' and prints the transpose in the same format.
        """.strip()

        print('Sending request to reasoning model...')

        completion = client.chat.completions.create(
            model="openai/gpt-6-sol",
            reasoning_effort="10000",
            messages=[
                {
                    "role": "user",
                    "content": prompt
                }
            ]
        )

        # Log the completion details
        print('\nCompletion Response:')
        print('-------------------')
        if completion.choices[0].message.content:
            print(completion.choices[0].message.content)

        # Log token usage details
        print('\nToken Usage Details:')
        print('-------------------')
        if completion.usage:
            usage_details = {
                "prompt_tokens": completion.usage.prompt_tokens,
                "completion_tokens": completion.usage.completion_tokens,
                "total_tokens": completion.usage.total_tokens
            }
            print(json.dumps(usage_details, indent=2))

            # Log specific reasoning token details if available
            if completion.usage.completion_tokens_details:
                print('\nReasoning Token Details:')
                print('----------------------')
                print(completion.usage.completion_tokens_details)

    except Exception as error:
        print(f'Error: {str(error)}')

if __name__ == '__main__':
    test_reasoning_budget()