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

# List Expert Models

> Use the /v3/info endpoints to discover all available expert model features, providers, and models.

export const TechArticleSchema = ({title, description, path, articleSection, about, proficiencyLevel = "Beginner", dependencies, keywords = [], datePublished, dateModified, image, inLanguage = "en"}) => {
  const baseUrl = "https://www.edenai.co/docs";
  const canonicalUrl = `${baseUrl}/${path}`.replace(/\/+$/, "");
  const ogParams = new URLSearchParams({
    division: articleSection || "",
    title: title || "",
    description: description || ""
  });
  const resolvedImage = image || `https://edenai.mintlify.app/_mintlify/api/og?${ogParams.toString()}`;
  const data = {
    "@context": "https://schema.org",
    "@type": "TechArticle",
    "@id": `${canonicalUrl}#techarticle`,
    mainEntityOfPage: {
      "@type": "WebPage",
      "@id": canonicalUrl
    },
    headline: title,
    name: title,
    description: description,
    url: canonicalUrl,
    inLanguage: inLanguage,
    isPartOf: {
      "@type": "WebSite",
      name: "Eden AI Documentation",
      url: baseUrl
    },
    author: [{
      "@type": "Organization",
      name: "Eden AI",
      url: "https://www.edenai.co/"
    }],
    publisher: {
      "@type": "Organization",
      name: "Eden AI",
      url: "https://www.edenai.co/",
      logo: {
        "@type": "ImageObject",
        url: "https://www.edenai.co/assets/logo.png"
      }
    }
  };
  if (articleSection) data.articleSection = articleSection;
  if (about) data.about = {
    "@type": "Thing",
    name: about
  };
  if (proficiencyLevel) data.proficiencyLevel = proficiencyLevel;
  if (dependencies) data.dependencies = dependencies;
  if (keywords && keywords.length) data.keywords = keywords;
  if (datePublished) data.datePublished = datePublished;
  if (dateModified) data.dateModified = dateModified;
  data.image = Array.isArray(resolvedImage) ? resolvedImage : [resolvedImage];
  const json = JSON.stringify(data);
  const schemaId = `techarticle-${canonicalUrl}`;
  React.useEffect(() => {
    if (typeof document === "undefined") return;
    document.querySelectorAll(`script[data-schema-id="${schemaId}"]`).forEach(n => n.remove());
    const script = document.createElement("script");
    script.type = "application/ld+json";
    script.dataset.schemaId = schemaId;
    script.textContent = json;
    document.head.appendChild(script);
    return () => script.remove();
  }, [json, schemaId]);
  return null;
};

<TechArticleSchema title={"List Expert Models"} description={"Use the /v3/info endpoints to discover all available expert model features, providers, and models."} path="v3/expert-models/listing-models" articleSection="Expert Models" about={"AI API"} proficiencyLevel="Intermediate" keywords={["Eden AI", "AI API", "expert models", "multi-provider"]} datePublished="2026-05-06T00:00:00Z" dateModified="2026-05-22T00:00:00Z" />

Use the `/v3/info` endpoints to discover all available expert model features, providers, and models.

## Endpoints

| Endpoint | Description | Query Parameters |
| - | - | - |
| `GET /v3/info` | List all features and subfeatures | `include=schemas`, and with it `format=simplified` or `format=json_schema` |
| `GET /v3/info/{feature}` | List the subfeatures of one feature | None |
| `GET /v3/info/{feature}/{subfeature}` | Get providers, models, pricing, and schemas for a specific feature | `format=simplified` or `format=json_schema` |
| `GET /v3/info/audio/tts/voices` | List the voices the text-to-speech models accept | `model`, `language`, `gender` |

## List All Features

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.edenai.run/v3/info \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

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

  response = requests.get(
      "https://api.edenai.run/v3/info",
      headers={"Authorization": "Bearer YOUR_API_KEY"}
  )

  for feature in response.json()["features"]:
      print(feature["name"])
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch("https://api.edenai.run/v3/info", {
    headers: { "Authorization": "Bearer YOUR_API_KEY" }
  });

  const { features } = await response.json();
  features.forEach(f => console.log(f.name));
  ```
</CodeGroup>

### Bulk Schema Discovery

To avoid querying each subfeature individually, pass `?include=schemas` to embed full schema bundles across all subfeatures in a single response:

<CodeGroup>
  ```bash cURL theme={null}
  curl "https://api.edenai.run/v3/info?include=schemas" \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

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

  response = requests.get(
      "https://api.edenai.run/v3/info?include=schemas",
      headers={"Authorization": "Bearer YOUR_API_KEY"}
  )

  for feature in response.json()["features"]:
      for subfeature in feature["subfeatures"]:
          fields = [field["name"] for field in subfeature["input_schema"]["fields"]]
          print(f'{feature["name"]}/{subfeature["name"]}:', ", ".join(fields))
  ```
</CodeGroup>

With `include=schemas`, each subfeature also carries the fields `GET /v3/info/{feature}/{subfeature}` returns: `endpoints`, `request_schema`, `input_schema`, `output_schema`, and `provider_params`. Add `format=json_schema` to get full JSON Schemas instead of the default simplified ones. `format` only applies to these schemas, so without `include=schemas` it has no effect.

## HTTP Caching and Conditional Requests

Every `/v3/info` route returns a weak `ETag` header alongside `Cache-Control: private, no-cache`. Keep the `ETag` of a response and send it back in an `If-None-Match` header: while the response is unchanged, the API answers `304 Not Modified` with an empty body, so polling the catalog costs no download.

<CodeGroup>
  ```python Python theme={null}
  import requests

  url = "https://api.edenai.run/v3/info"
  headers = {"Authorization": "Bearer YOUR_API_KEY"}

  first = requests.get(url, headers=headers)
  etag = first.headers["ETag"]

  # Later: ask again, sending back the ETag you kept
  second = requests.get(url, headers={**headers, "If-None-Match": etag})
  print(second.status_code)  # 304 while the catalog is unchanged
  ```

  ```javascript JavaScript theme={null}
  const url = "https://api.edenai.run/v3/info";
  const headers = { "Authorization": "Bearer YOUR_API_KEY" };

  const first = await fetch(url, { headers });
  const etag = first.headers.get("ETag");

  // Later: ask again, sending back the ETag you kept
  const second = await fetch(url, { headers: { ...headers, "If-None-Match": etag } });
  console.log(second.status); // 304 while the catalog is unchanged
  ```
</CodeGroup>

## Get Feature Details

Retrieve providers, pricing, endpoint paths, request/response schemas, and parameter allowlists for a specific feature.

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.edenai.run/v3/info/text/moderation \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

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

  response = requests.get(
      "https://api.edenai.run/v3/info/text/moderation",
      headers={"Authorization": "Bearer YOUR_API_KEY"}
  )

  details = response.json()
  for model in details.get("models", []):
      print(model["model"], model["pricing"])
  ```
</CodeGroup>

## Response Fields

### Subfeature Details

| Field | Description |
| - | - |
| `feature`, `subfeature` | Names used in the `model` string (e.g. `text` and `moderation`) |
| `feature_fullname`, `subfeature_fullname` | Display names |
| `description` | What the subfeature does |
| `mode` | `sync` for subfeatures you call with `POST /v3/universal-ai`, `async` for those you call with `POST /v3/universal-ai/async` and then poll |
| `endpoints` | The operations you can call, each as `METHOD /path`: `create` for a sync subfeature, `create`, `get`, `list`, and `delete` for an async one. Subfeatures backed by collections (`image/face_recognition`) add `create_collection`, `add_item`, and the other collection operations |
| `models` | List of available models with pricing, documentation links, and input constraints |
| `request_schema` | Top-level request body schema expected by the endpoint, showing where inputs nest |
| `input_schema` | Schema of the parameters accepted inside the `input` object |
| `output_schema` | Schema of the standardized response returned inside the `output` object |
| `provider_params` | For each provider, the `provider_params` it accepts on subfeatures that restrict them, or `null` on the others. See [Provider Parameters](/docs/v3/expert-models/provider-parameters#parameter-validation-and-allowlisting) |

### Model Metadata

Each entry in the `models` list contains:

| Field | Description |
| - | - |
| `model` | Full model identifier string (e.g. `text/moderation/google`) |
| `pricing` | Cost information including `price`, `price_unit_quantity`, `price_unit_type` (such as `request`, `second`, `execution_time`, `character`), and `currency` (`USD`) |
| `regions` | Regions the model is served from, as `code` and `name` objects (e.g. `eu` and `Europe`); empty when no region is recorded for the model |
| `documentation_url` | Direct URL to official provider documentation for the model or provider, or `null` |
| `requires_reference_images` | Boolean flag indicating whether the model requires `reference_images` (e.g. image edit models) |
| `requires_video` | Boolean flag indicating whether the model requires a source `video` input (e.g. video editing models) |
| `zero_data_retention` | `true` when the provider keeps no inputs or outputs after the response (Zero Data Retention), `false` when it keeps them, `null` when not verified yet |

<Tip>
  You can also browse all features and providers visually in the [Eden AI model catalog](https://app.edenai.run/models).
</Tip>

<Tip>
  Need models whose provider keeps no data? Add `?zero_data_retention=true` to `/v3/info`, `/v3/info/{feature}` or `/v3/info/{feature}/{subfeature}` to list only the model entries whose `zero_data_retention` is `true`.
</Tip>

<Tip icon="earth-europe">
  Need EU data residency? Hit `https://api.eu.edenai.run/v3/info` instead and the response is automatically filtered to EU-eligible providers and models. See [EU Endpoint](/docs/v3/data-governance/eu-endpoint).
</Tip>

<Note>
  Looking for LLMs like GPT-4o or Claude? See [List LLM Models](/docs/v3/llms/listing-models) for the full list of chat models.
</Note>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.