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

# List Models

> Retrieve a list of available AI models

Fetch comprehensive information about all available models, including their IDs, capabilities, and tier requirements.

### Headers

<ParamField header="x-api-key" type="string" required>
  Your Apollo AI API key.
</ParamField>

### Response

<ResponseField name="models" type="array">
  Array of model objects.

  <Expandable title="Model Object">
    <ResponseField name="id" type="string">
      The unique identifier for the model (e.g., `gpt-oss-120b`).
    </ResponseField>

    <ResponseField name="name" type="string">
      The human-readable name of the model.
    </ResponseField>

    <ResponseField name="description" type="string">
      A brief description of the model's capabilities.
    </ResponseField>

    <ResponseField name="endpoints" type="string[]">
      List of supported API endpoints for this model (e.g., `["/v1/generation/prompt"]`).
    </ResponseField>

    <ResponseField name="tier" type="string">
      The minimal subscription tier required to access this model (`starter`, `economy`, `pro`, `ultimate`).
    </ResponseField>

    <ResponseField name="multiplier" type="number">
      The token cost multiplier for this model.
    </ResponseField>
  </Expandable>
</ResponseField>

<RequestExample>
  ```bash Curl theme={null}
  curl -X GET "https://apolloai.lol/v1/models"
  ```

  ```python Python theme={null}
  import requests

  # For local development, use: http://localhost:3000/v1/models
  url = "https://apolloai.lol/v1/models"

  try:
      response = requests.get(url)
      response.raise_for_status()
      print(response.json())
  except requests.exceptions.HTTPError as err:
      print(f"HTTP Error: {err}")
      print(f"Response Body: {response.text}")
  except Exception as err:
      print(f"Error: {err}")
  ```

  ```javascript JavaScript theme={null}
  // For local development, use: http://localhost:3000/v1/models
  const url = "https://apolloai.lol/v1/models";

  fetch(url)
    .then(async response => {
      if (!response.ok) {
          const text = await response.text();
          throw new Error(`HTTP error! status: ${response.status}, body: ${text}`);
      }
      return response.json();
    })
    .then(console.log)
    .catch(console.error);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"net/http"
      "io/ioutil"
  )

  func main() {
      // For local development, use: http://localhost:3000/v1/models
  	url := "https://apolloai.lol/v1/models"
  	resp, err := http.Get(url)
      if err != nil {
          panic(err)
      }
      defer resp.Body.Close()
      
      body, _ := ioutil.ReadAll(resp.Body)
      
      if resp.StatusCode >= 400 {
          fmt.Printf("Error (Status %d): %s\n", resp.StatusCode, string(body))
      } else {
          fmt.Println(string(body))
      }
  }
  ```

  ```java Java theme={null}
  import java.net.URI;
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;
  import java.net.http.HttpResponse.BodyHandlers;

  public class Main {
      public static void main(String[] args) throws Exception {
          // For local development, use: http://localhost:3000/v1/models
          String url = "https://apolloai.lol/v1/models";

          HttpClient client = HttpClient.newHttpClient();
          HttpRequest request = HttpRequest.newBuilder()
              .uri(URI.create(url))
              .header("x-api-key", "<api_key>") // Header optional for public endpoints
              .GET()
              .build();

          client.sendAsync(request, BodyHandlers.ofString())
              .thenAccept(response -> {
                  if (response.statusCode() >= 400) {
                      System.out.println("Error (Status " + response.statusCode() + "): " + response.body());
                  } else {
                      System.out.println(response.body());
                  }
              })
              .join();
      }
  }
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'

  url = URI("https://apolloai.lol/v1/models")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true

  request = Net::HTTP::Get.new(url)
  request["x-api-key"] = "<api_key>"

  response = http.request(request)
  puts response.read_body
  ```

  ```c C theme={null}
  #include <stdio.h>
  #include <curl/curl.h>

  int main(void) {
    CURL *curl;
    CURLcode res;

    curl = curl_easy_init();
    if(curl) {
      curl_easy_setopt(curl, CURLOPT_URL, "https://apolloai.lol/v1/models");
      
      struct curl_slist *headers = NULL;
      headers = curl_slist_append(headers, "x-api-key: <api_key>");
      curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

      res = curl_easy_perform(curl);
      
      curl_slist_free_all(headers);
      curl_easy_cleanup(curl);
    }
    return 0;
  }
  ```

  ```rust Rust theme={null}
  use reqwest::Client;

  #[tokio::main]
  async fn main() -> Result<(), Box<dyn std::error::Error>> {
      let client = Client::new();
      let res = client.get("https://apolloai.lol/v1/models")
          .header("x-api-key", "<api_key>")
          .send()
          .await?;

      let body = res.text().await?;
      println!("{}", body);
      Ok(())
  }
  ```
</RequestExample>

<ResponseExample>
  ```json 200 OK theme={null}
  {
    "models": [
      { "id": "gpt-oss-120b", "name": "GPT OSS 120B", "provider": "OpenAI", "category": "OpenAI", "description": "High-performance 120B parameter model.", "endpoints": ["/v1/chat/completions"], "tier": "free", "multiplier": 3 },
      { "id": "qwen3-coder", "name": "Qwen3 Coder 480B", "provider": "Qwen", "category": "Free", "description": "Coding-optimized 480B parameter model.", "endpoints": ["/v1/chat/completions"], "tier": "free", "multiplier": 2 },
      { "id": "glm4", "name": "GLM 4.5 Air", "provider": "Z.AI", "category": "Free", "description": "GLM 4.5 Air model.", "endpoints": ["/v1/chat/completions"], "tier": "free", "multiplier": 2 },
      { "id": "llama3", "name": "Llama 3.3 70B", "provider": "Meta", "category": "Premium", "description": "High-performance reasoning and coding.", "endpoints": ["/v1/chat/completions"], "tier": "free", "multiplier": 1 },
      { "id": "opus-4.5", "name": "Claude Opus 4.5", "provider": "Anthropic", "category": "Premium", "description": "Anthropic's most powerful model.", "endpoints": ["/v1/chat/completions"], "tier": "pro", "multiplier": 10 },
      { "id": "sonnet-4.5", "name": "Claude Sonnet 4.5", "provider": "Anthropic", "category": "Premium", "description": "Balanced intelligence and speed.", "endpoints": ["/v1/chat/completions"], "tier": "free", "multiplier": 5 },
      { "id": "gemini-2.5-pro", "name": "Gemini 2.5 Pro", "provider": "Google", "category": "Premium", "description": "Google's latest Pro model.", "endpoints": ["/v1/chat/completions"], "tier": "pro", "multiplier": 5 },
      { "id": "gemini-2.5-flash", "name": "Gemini 2.5 Flash", "provider": "Google", "category": "Free", "description": "Fast and efficient Gemini model.", "endpoints": ["/v1/chat/completions"], "tier": "free", "multiplier": 1 },
      { "id": "gemini-3-pro", "name": "Gemini 3 Pro", "provider": "Google", "category": "Premium", "description": "Next-gen Gemini Pro model.", "endpoints": ["/v1/chat/completions"], "tier": "ultimate", "multiplier": 8 },
      { "id": "gemini-3-flash", "name": "Gemini 3 Flash", "provider": "Google", "category": "Free", "description": "Next-gen fast Gemini model.", "endpoints": ["/v1/chat/completions"], "tier": "free", "multiplier": 2 },
      { "id": "titan", "name": "Titan Image Generator G1 V2", "provider": "AWS", "category": "Image", "description": "AWS Titan Image Generator.", "endpoints": ["/v1/generation/image", "/v1/generation/image/edit"], "tier": "free", "multiplier": 5 }
    ]
  }
  ```

  ```json 429 Too Many Requests theme={null}
  {
    "error": "Daily quota exceeded."
  }
  ```
</ResponseExample>