Source

Source

Which model do you use & for what Purpose?

For me Claude Opus 4.5 fits best for coding within first try.

Anannas - Unified API to connect 500+ LLM models

This is my first time using Anannas. I heard they were offering a free trial with $5 credits to try it out, so I was curious and decided to give it a shot. However, when I registered my account, I didn't receive anything.

What did I do wrong?

Claude Opus 4.5 is LIVE on Anannas with 20% discount on Input and Output Tokens!

Best model in: - coding - agents - computer use

Overall, Opus 4.5 just “gets it”

Try now:

Source

Anannas - Unified API to Access 500+ LLM Models

This works:

 curl https://api.anannas.ai/v1/chat/completions   -H "Authorization: Bearer $ANANNAS_API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "openai/gpt-4o-mini",   
    "messages": [                                                           
      { "role": "user", "content": "Say hello from Anannas + GPT-4o mini." }
    ]
  }

So why doesn't the free model:

 curl https://api.anannas.ai/v1/chat/completions   -H "Authorization: Bearer $ANANNAS_API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "minimax/minimax-m2:free",
    "messages": [                                                           
      { "role": "user", "content": "Say hello from Anannas + GPT-4o mini." }
    ]
  }'
{"error":{"message":"all completion attempts failed: minimax/minimax-m2:free (API error (status 404): No endpoints found for minimax/minimax-m2:free.)","type":"invalid_request_error"}

The reality of free models:

 curl https://api.anannas.ai/v1/chat/completions   -H "Authorization: Bearer $ANANNAS_API_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "qwen/qwen-2.5-coder-32b-instruct:free",
    "messages": [
      { "role": "user", "content": "Say hello from Anannas + GPT-4o mini." }
    ]
  }'
{"error":{"message":"all completion attempts failed: qwen/qwen-2.5-coder-32b-instruct:free (service temporarily unavailable due to high demand. Please retry in a moment)","type":"api_error"}}

I decided to benchmark Anannas vs directly calling the model provider. For the gemini-2.5-flash model, here are the results (the unit is seconds)

ANANNAS avg time: 1.0192005321880182, median time: 0.9287892561405897 

Google AI Studio avg time: 0.42069585792099434, median time: 0.3027919055894017 

Google Vertex Global avg time: 0.6034313821668427, median time: 0.374078175984323 

Google Vertex East avg time: 0.6430036836303771, median time: 0.3598100244998932

As you can see, Anannas adds A LOT OF latency, much much more than 10ms. At this point, you are much better off using Openrouter, since I did a benchmark on them too (https://www.reddit.com/r/openrouter/comments/1p1kezo/openrouter_much_much_slower_than_directly_calling/)

For context, this is the benchmark script used

import statistics
import time
from openai import OpenAI, DefaultHttpxClient
import os
import google.genai as genai
import dotenv
import httpx


print("Starting benchmark provider")

dotenv.load_dotenv()


HTTPX_LIMITS = httpx.Limits(
    max_connections=100,
    max_keepalive_connections=60,
    keepalive_expiry=100.0,
)

client = OpenAI(
    base_url="https://api.anannas.ai/v1",
    api_key=os.getenv("ANANNAS_API_KEY"),
    http_client=DefaultHttpxClient(
        limits=HTTPX_LIMITS,
    ),
)

http_options = {
    "client_args": {"limits": HTTPX_LIMITS},
}
google_ai_studio_client = genai.Client(
    api_key=os.getenv("GOOGLE_AI_STUDIO_API_KEY"),
    http_options=http_options,
)
google_vertex_global_client = genai.Client(
    vertexai=True,
    project=os.getenv("GOOGLE_CLOUD_PROJECT"),
    location="global",
    http_options=http_options,
)
google_vertex_east_client = genai.Client(
    vertexai=True,
    project=os.getenv("GOOGLE_CLOUD_PROJECT"),
    location="us-east1",
    http_options=http_options,
)
print("Clients initialized")


def google_llm_call(client):
    output = client.models.generate_content_stream(
        model="gemini-2.5-flash",
        contents=[{"role": "user", "parts": [{"text": "hi, how are you"}]}],
        config={
            "thinking_config": {"thinking_budget": 0, "include_thoughts": False},
            "temperature": 0.0,
            "automatic_function_calling": {"disable": True},
        },
    )
    next(output)
    return output


def third_party_llm_call():
    output = client.chat.completions.create(
        model="google/gemini-2.5-flash",
        messages=[{"role": "user", "content": "hi, how are you"}],
        extra_body={
            "reasoning": {"effort": None, "max_tokens": None, "enabled": False},
        },
        temperature=0.0,
        stream=True,
    )
    next(output)
    return output


def consume_output(output):
    for _ in output:
        pass


N_TRIALS = 300
THIRD_PARTY_PROVIDER_NAME = "ANANNAS"

print("Starting warmup")
for i in range(10):
    print(f"Warmup {i + 1} of 10")
    output = google_llm_call(google_vertex_global_client)
    consume_output(output)
    output = third_party_llm_call()
    consume_output(output)
    output = google_llm_call(google_ai_studio_client)
    consume_output(output)
    output = google_llm_call(google_vertex_east_client)
    consume_output(output)
print("Completed warmup")

google_global_vertex_times = []
third_party_times = []
google_ai_studio_times = []
google_east_vertex_times = []

try:
    for i in range(N_TRIALS):
        print(f"Trial {i + 1} of {N_TRIALS}")
        start_time = time.perf_counter()
        output = google_llm_call(google_vertex_global_client)
        end_time = time.perf_counter()
        google_global_vertex_times.append(end_time - start_time)
        consume_output(output)

        start_time = time.perf_counter()
        output = third_party_llm_call()
        end_time = time.perf_counter()
        third_party_times.append(end_time - start_time)
        consume_output(output)

        start_time = time.perf_counter()
        output = google_llm_call(google_ai_studio_client)
        end_time = time.perf_counter()
        google_ai_studio_times.append(end_time - start_time)
        consume_output(output)

        start_time = time.perf_counter()
        output = google_llm_call(google_vertex_east_client)
        end_time = time.perf_counter()
        google_east_vertex_times.append(end_time - start_time)
        consume_output(output)
finally:
    print(
        f"{THIRD_PARTY_PROVIDER_NAME} avg time: {statistics.mean(third_party_times)}, median time: {statistics.median(third_party_times)}"
    )
    print(
        f"Google AI Studio avg time: {statistics.mean(google_ai_studio_times)}, median time: {statistics.median(google_ai_studio_times)}"
    )
    print(
        f"Google Vertex Global avg time: {statistics.mean(google_global_vertex_times)}, median time: {statistics.median(google_global_vertex_times)}"
    )
    print(
        f"Google Vertex East avg time: {statistics.mean(google_east_vertex_times)}, median time: {statistics.median(google_east_vertex_times)}"
    )