fal APIfal.ai ↗
Query the fal.ai public model gallery. Search, filter by category, sort by trending or recent, and retrieve model IDs, tags, pricing text, and more.
What is the fal API?
The fal.ai API gives programmatic access to the fal.ai public model gallery, which lists roughly 1,500 AI model endpoints at the time of writing. The single list_models endpoint returns paginated model records including each model's unique endpoint identifier, category, tags, lab or family, license, publication date, and the pricing text fal.ai publishes — making it straightforward to track what models are available and what they cost to run on the platform.
curl -X GET 'https://api.parse.bot/scraper/8000890c-6978-4ad0-9816-553e40a3932f/list_models?category=text-to-image' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace fal-ai-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: fal.ai Model Catalog — browse, filter, and search models."""
from parse_apis.fal_ai_api import FalAi, ModelSort, ModelCategory, InputFormatInvalid
client = FalAi()
# Browse trending text-to-image models, capped at 5 total items.
for model in client.models.list(category=ModelCategory.TEXT_TO_IMAGE, sort=ModelSort.TRENDING, limit=5):
pricing = model.pricing_text or "no pricing published"
print(f"{model.title} ({model.model_id}) — {pricing}")
# Search by keyword and drill into the first match.
try:
top_hit = client.models.list(keywords="flux", limit=1).first()
except InputFormatInvalid as e:
print(f"Bad request: {e.message}")
top_hit = None
if top_hit is not None:
print(f"\n{top_hit.title}")
print(f" lab: {top_hit.model_lab} family: {top_hit.model_family}")
print(f" license: {top_hit.license_type} category: {top_hit.category}")
print(f" published: {top_hit.published_at}")
if top_hit.price_amounts_usd:
print(f" price points (USD): {top_hit.price_amounts_usd}")
print(f" page: {top_hit.page_url}")
# List recently added models across all categories.
for model in client.models.list(sort=ModelSort.RECENT, limit=3):
print(f"{model.title} [{model.category}] — {model.published_at:%Y-%m-%d}")
print("\nexercised: models.list (trending / keyword search / recent)")
Returns one page of models from the fal.ai public model gallery (about 1500 models at the time of writing). Each row is one model endpoint with its title, category, tags, lab/family, license, publication date and the pricing text fal.ai publishes for it (pricing_text is the site's human-readable pricing statement, e.g. one shape: 'Your request will cost $0.15 per image ...'; price_amounts_usd lists every dollar amount found in that text, in order, as numbers). Some models have no public pricing statement on the site; for those pricing_text is null and price_amounts_usd is an empty list. Supports free-text keyword search, a single category filter, sort by trending or most-recently-added, and page/limit pagination (one upstream call per page; limit is clamped to 100). An unknown category or a page past total_pages returns an empty models list with the source total. Deprecated models are excluded.
| Param | Type | Description |
|---|---|---|
| page | integer | 1-based page number. A page beyond total_pages returns an empty models list. |
| sort | string | Result ordering: trending (the gallery default) or recent (most recently added first). |
| limit | integer | Models per page, clamped to a maximum of 100. |
| category | string | Category filter (the gallery's Category checkbox list); a single category code. Omitted = all categories. Values not in the list are passed through to the site and yield an empty result. |
| keywords | string | Free-text search over model names/descriptions (the gallery search box). Omitted = no keyword filter. |
{
"type": "object",
"fields": {
"page": "integer, echoed page number",
"total": "integer, total matching models reported by the site",
"models": "array of model records for this page",
"has_more": "boolean, true when page < total_pages",
"page_size": "integer, effective limit after clamping",
"total_pages": "integer, number of pages reported by the site for this filter",
"models[].tags": "array of tag strings",
"models[].model_id": "fal.ai endpoint identifier (e.g. owner/name/variant), unique per row",
"models[].page_url": "public model page on fal.ai",
"models[].hide_pricing": "boolean flag from the site indicating pricing is intentionally hidden",
"models[].pricing_text": "site-published pricing statement, markdown emphasis removed; null when the site publishes no pricing for the model",
"models[].published_at": "ISO-8601 timestamp the model was published",
"models[].billing_message": "additional billing note shown by the site, or null",
"models[].price_amounts_usd": "numbers: every $ amount appearing in pricing_text, in order; empty when pricing_text is null"
},
"sample": {
"data": {
"page": 1,
"total": 1500,
"models": [
{
"kind": "inference",
"tags": [],
"title": "Nano Banana 2",
"category": "image-to-image",
"model_id": "fal-ai/nano-banana-2/edit",
"page_url": "https://fal.ai/models/fal-ai/nano-banana-2/edit",
"model_lab": "Google",
"deprecated": false,
"hide_pricing": false,
"hosting_type": "proxy",
"license_type": "commercial",
"model_family": "Nano Banana 2",
"pricing_text": "Your request will cost $0.08 per image. For $1.00, you can run this model 12 times. 2K and 4K outputs will be charged at 1.5 times and 2 times the standard rate, respectively. 0.5K (512px) resolution outputs will be charged at 0.75 times the standard rate. If web search is used, an additional $0.015 will be charged. If high thinking is used, an additional $0.002 will be charged. Note: Pricing is subject to change.",
"published_at": "2026-02-26T16:20:09.685Z",
"thumbnail_url": "https://v3b.fal.media/files/b/0a900b75/DHb_RgXoXsYLdvzQz6mdn_95e87a44239c43448939b4c382dd957c.jpg",
"billing_message": null,
"price_amounts_usd": [
0.08,
1,
0.015,
0.002
],
"short_description": "Nano Banana 2 is Google's new state-of-the-art image generation and editing model\n"
},
{
"kind": "inference",
"tags": [
"background removal",
"segmentation",
"utility"
],
"title": "Birefnet Background Removal V2",
"category": "image-to-image",
"model_id": "fal-ai/birefnet/v2",
"page_url": "https://fal.ai/models/fal-ai/birefnet/v2",
"model_lab": null,
"deprecated": false,
"hide_pricing": false,
"hosting_type": "serverless",
"license_type": "commercial",
"model_family": "Birefnet",
"pricing_text": null,
"published_at": "2024-10-28T00:00:00.000Z",
"thumbnail_url": "https://storage.googleapis.com/falserverless/gallery/birefnet.webp",
"billing_message": null,
"price_amounts_usd": [],
"short_description": "bilateral reference framework (BiRefNet) for high-resolution dichotomous image segmentation (DIS)"
}
],
"has_more": true,
"page_size": 24,
"total_pages": 63
},
"status": "success"
}
}About the fal API
What list_models returns
Each call to list_models returns a page of model records from the fal.ai gallery. Every record includes model_id (the owner/name/variant endpoint identifier used to call models on fal.ai), page_url (the public model page), tags, category, lab/family, license, and pricing_text as published by fal.ai. A hide_pricing boolean flags models where fal.ai intentionally omits pricing details. The response envelope includes total, total_pages, page_size, and has_more to support standard pagination.
Filtering and sorting
list_models accepts a keywords parameter for free-text search over model names and descriptions, and a category parameter to narrow results to a single category from the gallery's category list. Results can be ordered with the sort parameter: trending (the gallery default) or recent (most recently published first). The limit parameter controls page size up to a maximum of 100 models per page, and page is 1-based. Requesting a page beyond total_pages returns an empty models array rather than an error.
Coverage and freshness
The gallery covered approximately 1,500 models at the time of writing. Because fal.ai adds new models regularly, the total field in each response reflects the current count at query time. Filtering by sort=recent is the most reliable way to detect newly published models. Models that fal.ai marks as hidden-pricing will still appear in results; hide_pricing: true simply signals that pricing_text will not be populated for those rows.
The fal API is a managed, monitored endpoint for fal.ai — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when fal.ai changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official fal.ai API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a price-comparison dashboard for AI image, video, and audio generation models using
pricing_textandmodel_id. - Monitor the fal.ai gallery for newly published models by polling
list_modelswithsort=recentand tracking newmodel_idvalues. - Filter models by category to surface only image-generation or speech-synthesis endpoints relevant to a specific workflow.
- Index fal.ai model metadata — tags, license, lab/family — into an internal catalog for team model selection.
- Track which models switch from published pricing to
hide_pricing: trueover time as part of competitive intelligence. - Generate a curated model recommendation list for an application by searching
keywordsand reading back category and tag data. - Sync fal.ai model availability and pricing text into a product pricing page that lists third-party AI service costs.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does fal.ai have an official developer API?+
What does the `model_id` field represent and how is it formatted?+
model_id is the fal.ai endpoint identifier in owner/name/variant format (for example, fal-ai/flux/dev). It is unique per row and is the same identifier used to call a model through fal.ai's inference API. Combined with page_url, it gives you everything needed to link directly to or invoke any model in the gallery.Can I retrieve individual model detail pages or run inference through this API?+
What happens to `pricing_text` when a model has hidden pricing?+
hide_pricing is true, fal.ai intentionally does not publish a price for that model, so pricing_text will not contain a usable value for those rows. The field may be null or empty. All other metadata fields — model_id, tags, category, license, and page_url — are still populated normally.Is there a way to retrieve all models in a single request?+
limit parameter is clamped to a maximum of 100 models per page. With roughly 1,500 models in the gallery, a full retrieval requires iterating through multiple pages using the page parameter and checking has_more or comparing page against total_pages.