LLM leaderboard

Compare large language models by price, context window and more, to find the best match for your needs.

Leaderboard
Largest context
  1. GPT-6.1 Terra
  2. GPT-6.1 Sol
  3. GPT-6 Luna
Highest output tokens
  1. Grok 4.7
  2. DeepSeek V4.1 Flash 1017
  3. DeepSeek V4 Pro
Least expensive
  1. Ministral 3 8B
  2. Gemini 2.5 Flash-Lite
  3. Claude Haiku 5.5
Model comparison
Model
Input price / 1M tokens
Output price / 1M tokens
Context window
Output token limit
Reasoning model
Open source
GPT-6 Luna
$0.10
$0.50
1050000128000
Claude Haiku 5.5
$0.10
$0.50
1000000128000
Gemini 2.5 Flash-Lite
$0.10
$0.40
104857665536
Mistral Small 4
$0.15
$0.60
262144256000
Ministral 3 8B
$0.15
$0.15
262144262144
DeepSeek V4.1 Flash 1017
$0.15
$0.60
1048576393216
Qwen3.8 Omni Flash
$0.15
$0.47
1000000131072
Qwen3.8 Flash
$0.15
$0.47
1000000131072
Gemini 3.5 Flash Lite
$0.30
$2.50
104857665536
Devstral 2
$0.40
$2.00
262144262144
Qwen3.7 Plus
$0.40
$1.60
1000000131072
Qwen3.6 27B
$0.60
$3.60
26214465536
DeepSeek V4 Pro
$0.66
$1.98
1048576393216
Mistral Large 4
$0.70
$2.10
1048576262144
Gemini 3.8 Flash
$0.75
$3.75
104857665536
GPT-6.1 Terra
$1.00
$5.00
1050000128000
Grok Build 0.1
$1.00
$2.00
256000256000
Muse Spark 1.3
$1.25
$4.25
1048576131072
Grok 4.20 Multi-Agent
$1.25
$2.50
100000030000
Mistral Medium 3.5
$1.50
$7.50
262144262144
GPT-6.1 Sol
$2.00
$10.00
1050000128000
Claude Sonnet 5.5
$2.00
$10.00
1000000128000
Gemini 4 Argon
$2.00
$10.00
104857632768
Gemini 3.1 Pro Preview
$2.00
$12.00
104857665536
Grok 4.7
$2.00
$6.00
500000500000
Qwen3.8 Max
$2.00
$6.00
1000000131072
GPT-5.6
$4.00
$20.00
1050000128000
Claude Opus 5.5
$4.00
$20.00
1000000128000
Muse Wonder
$4.00
$20.00
1048576131072
GPT-6 Astra
$10.00
$50.00
1050000128000
Claude Fable 5.1
$10.00
$50.00
1000000128000
Key definitions
Price:Price per token refers to the cost of processing each token in the prompt sent to an LLM, while output price per token is the cost of each token generated by the model in response. The price shown in the leaderboard section is a blended price, using a typical ratio of 3:1 of input to output usage. Some models have a price of 0, which can be in the case of a limited free trial.
Context window:The maximum amount of text (tokens) the model can process at once, including both input and generated output. It determines how much prior conversation or document history the model can "remember" within a single interaction.
Output token limit:Maximum output tokens define the upper limit of tokens an LLM can generate in a single response. This limit is influenced by the model's context window and provider policies, dictating the length of its output.
Reasoning model:A reasoning LLM signifies a model capable of going beyond pattern recognition to perform logical inference and problem-solving. This involves tasks like complex mathematics, planning, and generating "chain of thought" explanations, mimicking human-like cognitive processes. Essentially, it aims to understand and solve problems, not just reproduce text.
Open source:Some LLMs are published under an open-source license, allowing developers to access and modify the code, and this means you are also able to host these models yourself on premises or in the cloud. Others, such as Mistral, are available for self-hosting under licence.

Large Language Models (LLMs) are a type of AI system trained on massive amounts of text data. They learn patterns, relationships, and structures in language, allowing them to generate human-like text, translate languages, answer questions, and perform various other language-based tasks. They typically use neural networks (often transformer models) as their underlying architecture. Modern LLMs can perform a wide range of tasks including writing, translation, summarization, question answering, code generation, and reasoning.

LLMs are large neural networks, specifically transformer architectures, that process and generate text. During training, the neural networks learn to identify patterns and relationships within massive datasets of text, by accomplishing tasks like predicting the next word in a sequence. When prompted, the neural networks use their learnt parameters to generate coherent and relevant text given the provided context.

LLM training is a two-stage process: pre-training and fine-tuning. During pre-training, models learn general language patterns. During fine-tuning, models learn to accurately accomplish a variety of tasks like answering questions, summarizing text, generating code, identifying entities and importantly, following human instructions.

LLMs are capable of solving a diversity of natural language understanding and generation tasks. They can of course generate content, from business emails to children stories. They are capable of extracting information from the provided context, summarizing and analyzing text, and translating between languages.

We can access LLMs in multiple ways. Either directly through the provider’s console or API, but also by self-hosting and on cloud providers’ platforms.

Using the provider console : ChatGPT, Gemini AI studio, Claude allow us to chat with their state-of-the-art LLM models either as a free or paid method.

APIs : Almost all providers (OpenAI, Gemini, Claude, etc) allow users to use their LLMs via paid service using APIs. This is the easiest way for one to integrate with their applications and leverage AI capabilities.

Self-hosting : Research teams have released open-source LLMs (Deepseek-R1, Gemma 3, Llama 3.3, Mistral, Phi-4) allowing us to download and run them on our local machine or in cloud instances. This gives more control over the model, but may require significant computational resources and technical expertise. That said, almost all open-source versions have smaller model flavours (with fewer parameters) that are distilled from the larger models, such as Deepseek R1 1.5B and Llama 3 7B. These can be more easily hosted on local machines with decent specifications (sometimes without GPUs as well). One can interact with them either on the command line using tools like llama.cpp and ollama, or with a web interface like open-webui or text-generation-webui.

Cloud-based platforms : Cloud providers (e.g., AWS, Azure, GCP) offer managed services that allow you to deploy and run LLMs on their infrastructure. This provides a balance between control and ease of use.

It depends on the deployment method and expected usage.

Utilizing LLMs through provider APIs incurs costs based on usage, billed by token consumption.

Self-hosting open-source LLMs may require substantial computational resources, particularly GPUs. This approach offers greater control and privacy, but GPUs need to be highly utilized for it to be cheaper than using provider APIs.

Cloud providers offer managed LLM services that balance cost and control. Pricing models vary, but often involve a combination of compute and usage-based charges.

LLMs represent a significant advancement over traditional Natural Language Processing (NLP) techniques. They generalize better, which allows them to solve very diverse tasks effectively. Being trained on large text corpuses, they embed strong priors about natural language, producing human-like text. Finally, they are computationally efficient and can use GPUs (which are highly parallel processors) very well.

GPT (Generative Pre-trained Transformer) is a specific family of Large Language Models developed by OpenAI. The term LLM is a more generic term referring to any large language model. GPT designates a specific implementation and architecture, and therefore GPT is an LLM.

These are the number of parameters in the LLM, in billions. LLMs are neural networks that are built from matrices: the no. parameters is the total no. elements in these matrices. Parameters are learnt during the training process and then used to make predictions. The higher the number of parameters, the more complex patterns the model can learn. In most cases, they are also directly proportional to the model’s performance. However, more parameters require higher computational resources to run the models (essentially GPU memory and bandwidth).


While previous iterations of LLMs were primarily trained on vast amounts of text, newer models are also trained on non-textual data like images, audio and video thanks to specialized encoders that act as translators. These encoders convert images or audio into numerical representations (vector embeddings) that the LLM can understand. On the output side, corresponding decoders generate text, but may also generate images and audio. Therefore, modern iterations can support various modalities, combining them to solve complex tasks.