> ## Documentation Index
> Fetch the complete documentation index at: https://developers.meshapi.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Model Compare

> Send the same prompt to multiple models in parallel and compare their responses.

The Compare API fans out a single request to multiple models simultaneously and returns all responses together. This is useful for evaluating model quality side by side.

## Non-streaming compare

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    from meshapi import MeshAPI, CompareParams, ChatMessage

    client = MeshAPI(base_url="https://api.meshapi.ai", token="rsk_...")

    result = client.compare.create(
        CompareParams(
            models=["openai/gpt-4o-mini", "anthropic/claude-haiku-4.5"],
            messages=[ChatMessage(role="user", content="Explain what an API is in one sentence.")],
            skip_comparison=True,
            max_tokens=100,
        )
    )

    for r in result.results:
        print(r.model, r.content)
    ```
  </Tab>

  <Tab title="Node.js">
    ```javascript theme={null}
    const result = await client.compare.create({
      models: ["openai/gpt-4o-mini", "anthropic/claude-haiku-4.5"],
      messages: [{ role: "user", content: "Explain what an API is in one sentence." }],
      skip_comparison: true,
      max_tokens: 100,
    });

    result.results.forEach(r => {
      console.log(r.model, r.content);
    });
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    maxTokens := 100
    skip := true

    resp, err := client.Compare.Create(ctx, meshapi.CompareParams{
        Models: []string{"openai/gpt-4o-mini", "anthropic/claude-haiku-4.5"},
        Messages: []meshapi.ChatMessage{
            {Role: "user", Content: "Explain what an API is in one sentence."},
        },
        MaxTokens:      &maxTokens,
        SkipComparison: &skip,
    })
    if err != nil {
        log.Fatal(err)
    }
    for _, r := range resp.Results {
        fmt.Println(r.Model, *r.Content)
    }
    ```
  </Tab>
</Tabs>

## Streaming compare

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    events = list(
        client.compare.stream(
            CompareParams(
                models=["openai/gpt-4o-mini", "anthropic/claude-haiku-4.5"],
                messages=[ChatMessage(role="user", content="Tell me a joke.")],
                skip_comparison=True,
                max_tokens=100,
            )
        )
    )
    print(f"received {len(events)} events")
    ```
  </Tab>

  <Tab title="Node.js">
    ```javascript theme={null}
    let events = 0;
    for await (const _event of client.compare.create({
      models: ["openai/gpt-4o-mini", "anthropic/claude-haiku-4.5"],
      messages: [{ role: "user", content: "Tell me a joke." }],
      skip_comparison: true,
      max_tokens: 100,
      stream: true,
    })) {
      events++;
    }
    console.log(`received ${events} events`);
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    maxTokens := 100
    skip := true

    eventCh, errCh := client.Compare.Stream(ctx, meshapi.CompareParams{
        Models: []string{"openai/gpt-4o-mini", "anthropic/claude-haiku-4.5"},
        Messages: []meshapi.ChatMessage{
            {Role: "user", Content: "Tell me a joke."},
        },
        MaxTokens:      &maxTokens,
        SkipComparison: &skip,
    })

    count := 0
    for range eventCh {
        count++
    }
    if err := <-errCh; err != nil {
        log.Fatal(err)
    }
    fmt.Printf("received %d events\n", count)
    ```
  </Tab>
</Tabs>

## Parameters

| Parameter         | Description                                                  |
| ----------------- | ------------------------------------------------------------ |
| `models`          | Array of model IDs to compare (2+)                           |
| `messages`        | Conversation messages sent to all models                     |
| `skip_comparison` | Set to `true` to return raw results without a synthesis step |
| `max_tokens`      | Maximum tokens per model response                            |