# Free LLM API Endpoints: Live-Tested Models, Ranked (`superslowsloth/free-llm-api-endpoints`) Actor

Free LLM API endpoints that work right now, live-probed hourly and ranked: base URL, model ID, key requirement, latency and proven tool, JSON and vision support.

- **URL**: https://apify.com/superslowsloth/free-llm-api-endpoints.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 endpoint listeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Free LLM API Endpoints: live-tested, ranked, with a fallback chain

Get the **free LLM API endpoints that work right now**, as structured rows: base
URL, model ID, whether a key is needed, latency, recent success rate, and which
capabilities (tool calling, JSON schema, JSON mode, vision, image generation)
a real call proved. The list comes from [stillworks](https://stillworks.supercapybara.com),
a registry that re-probes every endpoint hourly with a real request, and it is
returned **ranked**: row 1 is the pick, the rest is your fallback chain.

No login, no proxy and no API key are needed to run this actor.

### Why the ranking matters

Free LLM endpoints are other people's services. Keyless quotas are usually
per IP address, so the endpoint that answered stillworks can still refuse you
with a 402 or 429. Instead of one answer you get an ordered list: try row 1,
and on a refusal walk down to row 2. Ranking is "no key needed first, then
recent success rate, then latency" (the exact wording is in the run log).

### What you can do with it

- Pick a working free, OpenAI-compatible `base_url` and model for an agent, a
  CI job, a prototype or a demo, without reading ten provider pages.
- Build a fallback chain across providers and re-pull it on a schedule, so a
  dead free endpoint drops out of your config instead of breaking production.
- Find the free models that actually do tool calling, JSON schema output or
  vision, as proven by a call and not as claimed in a docs page.
- Monitor which free LLM providers are up, how fast they answer and how often
  they succeed.

### Input

| Field | Type | Notes |
|---|---|---|
| `auth` | string | `none` (default): endpoints that answered a real call with **no Authorization header**. `key`: endpoints that need your own API key (stillworks verified them with its own free-tier key). `any`: both shelves together, keyless first. |
| `features` | array | Any of `tools`, `json_schema`, `json_object`, `vision`, `image_out`. Combined with AND, so you get models that do **all** of them. Models never probed for a capability are left out. `image_out` cannot be combined with another feature. |
| `maxItems` | integer | Keep the first N rows of the ranked list (1 to 50, default 50). The API returns at most 50 models per call. |

An unknown value for `auth` or `features` fails the run up front with a clear
message, before anything is charged. It never silently returns a wider list.

Example input:

```json
{ "auth": "none", "features": ["tools"], "maxItems": 10 }
```

### Output

One dataset row per endpoint/model pair, best first. The fields are the API's
own, plus `rank` and `stillworks_url`.

```json
{
  "rank": 1,
  "endpoint": "pollinations",
  "model": "openai-fast",
  "tier": "anonymous",
  "base_url": "https://text.pollinations.ai",
  "chat_path": "/openai",
  "openai_base_url": "https://text.pollinations.ai/openai",
  "auth_mode": "none",
  "auth": "none",
  "chat_capable": true,
  "openai_compatible": true,
  "last_ok": "2026-10-12T06:23:57.592923Z",
  "latency_ms": 355,
  "recent_attempts": 168,
  "recent_successes": 168,
  "answered": "168/168",
  "proved": ["json_schema", "json_object"],
  "claimed_unproved": [],
  "failed": ["tools"],
  "capabilities": {
    "json_schema": { "claimed": null, "supported": true, "checked_at": "2026-10-11T17:08:30.817873Z", "last_ok": "2026-10-11T17:08:30.817873Z" },
    "tools": { "claimed": true, "supported": false, "checked_at": "2026-10-11T17:08:00.338317Z", "last_ok": null, "last_error": "answered without calling the tool" }
  },
  "key_note": null,
  "generated_at": "2026-10-12T06:26:23.813289476Z",
  "stillworks_url": "https://stillworks.supercapybara.com/llm/pollinations"
}
```

- `openai_base_url` is the value to give an OpenAI SDK as `base_url`; `model` is the model ID.
- `auth` is `none` (send no `Authorization` header) or `bearer` (send your own key).
- `proved`, `claimed_unproved` and `failed` separate what a real call showed from what the provider says it supports. `capabilities` holds the detail, including the last error.
- `tier` and `last_ok` are `null` when stillworks has no value, never a placeholder.
- `key_note` is filled only for endpoints that need your own key: those were verified with stillworks' own free-tier key, which proves the endpoint answers today, not what a new signup's free tier includes.

### Notes on the data

- **Verified from stillworks' address, not yours.** Quotas are commonly per IP and per account, so a listed endpoint can still answer 402 or 429 from your network. That is exactly why the result is a ranked chain.
- **The list moves.** Providers add key requirements, change models and disappear. Rows reflect the hourly probe whose time is in `last_ok` and `generated_at`.
- **An empty result is a real answer.** If nothing is currently proven for your filter (for example image generation with `auth: key`), the run finishes with an empty dataset and is not charged per row.
- Calls to the stillworks API identify themselves with the `User-Agent` `stillworks-apify-actor/1.0`.

### Billing

Pay per event: a small `actor-start` event per run, plus one `endpoint-listed`
event per row delivered. The event is charged after the row is written to the
dataset, so you are never billed for a row you did not receive.
Platform usage is included in the event prices.

### Related

Live registry and docs: <https://stillworks.supercapybara.com>. The same data
is a plain public JSON API at `https://stillworks.supercapybara.com/api/llm/up`
if you would rather call it directly from your own code.

# Actor input Schema

## `auth` (type: `string`):

Which endpoints to list. 'No key needed' (default) returns only endpoints that answered a real call with no Authorization header at all. 'Own key required' returns endpoints that need your own API key (stillworks verified them with its own free-tier key). 'Both' returns the two shelves together, keyless first.

## `features` (type: `array`):

Only list models where a real call proved every capability chosen here (they are combined with AND, so you get one model that does all of them). Models never probed for a capability are left out. 'Image generation' cannot be combined with another capability, because no model both draws and chats. Leave empty for no capability filter.

## `maxItems` (type: `integer`):

Keep only the first N rows of the ranked list. Row 1 is the pick and the rest is the fallback chain, so the top N are the best N. The stillworks API returns at most 50 models per call, so 50 is the ceiling.

## Actor input object example

```json
{
  "auth": "none",
  "maxItems": 50
}
```

# Actor output Schema

## `endpoints` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/free-llm-api-endpoints").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/free-llm-api-endpoints").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call superslowsloth/free-llm-api-endpoints --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,superslowsloth/free-llm-api-endpoints"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6y2uV477Jab7mTQoo/builds/3tYjcyim3FCHT7Xer/openapi.json