Fal AI connector for AI agents

Tools your media agent reaches for on Fal AI, scoped per user.

CALL ANY TOOL

29 tools for generative media in Fal AI: search models and compare pricing, run or queue requests, check status and fetch results, browse and organize assets, review workflows, and track usage, analytics, and billing.

fal_add_asset_to_collection

Add asset to collection

Add an asset to a manual fal Assets collection. Returns success true when added. Provide exactly one of asset_id, request_id or vector_id.

Parameters

Name

Type

Required

Description

collection_id

string

Required

ID of the collection to add to.

asset_id

string

Optional

Asset ID to add.

request_id

string

Optional

Request ID whose output to add as an asset.

vector_id

string

Optional

Vector ID of the asset to add.

fal_browse_assets

Browse assets

fal_cancel_request

Cancel request

fal_create_asset_collection

Create asset collection

fal_delete_request_payloads

Delete request payloads

fal_estimate_cost

Estimate cost

fal_get_account_billing

Get account billing

fal_get_app_queue_size

Get app queue size

fal_get_asset

Get asset

fal_get_asset_collection

Get asset collection

fal_get_model_analytics

Get model analytics

fal_get_model_pricing

Get model pricing

fal_get_model_usage

Get model usage

fal_get_request_result

Get request result

fal_get_request_status

Get request status

fal_get_workflow

Get workflow

fal_list_asset_collections

List asset collections

fal_list_asset_tags

List asset tags

fal_list_billing_events

List billing events

fal_list_requests_by_endpoint

List requests by endpoint

fal_list_serverless_apps

List serverless apps

fal_list_workflows

List workflows

fal_run_model

Run model

fal_search_models

Search models

fal_search_requests

Search requests

fal_sign_file_url

Sign file url

fal_submit_request

Submit request

fal_update_asset_collection

Update asset collection

fal_upload_asset

Upload asset

Build your Agent

Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.

import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Fal AI tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["fal"], toolNames: [
    "fal_search_models",
    "fal_submit_request",
    "fal_get_request_result"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Find a text-to-image model and generate a red bicycle in Tokyo" }] });

import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["fal"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Find a text-to-image model and generate a red bicycle in Tokyo" }],
  tools,
});

// Execute the tool call with the user's vaulted Fal AI API key
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");

import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["fal"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Find a text-to-image model and generate a red bicycle in Tokyo" }],
  tools,
});

// Tool call runs with the user's vaulted Fal AI API key
await sk.tools.executeTool(msg.content, "user_123");

import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["fal"] }, pageSize: 100,
});

const agent = new Agent({
  name: "media_agent",
  model: "gemini-2.5-pro",
  instruction: "Fal AI tools scoped to this user",
  tools,
});

await agent.run("Find a text-to-image model and generate a red bicycle in Tokyo");

Try these prompts

Copy any prompt into your agent. Each maps directly to a Fal AI tool. Click to copy, paste into your agent, done.

Models

Copy the prompt

Copied

Find text-to-video models on fal and show their pricing.

Copy the prompt

Copied

Estimate the cost of 200 image generations on this endpoint.

Copy the prompt

Copied

Generate an image of a red bicycle in Tokyo with this model.

Requests

Copy the prompt

Copied

Queue this video generation and tell me when it finishes.

Copy the prompt

Copied

Fetch the result of my last request and give me the media URLs.

Copy the prompt

Copied

Cancel the request I submitted by mistake.

Assets and billing

Copy the prompt

Copied

Search our assets for product images on a white background.

Copy the prompt

Copied

Create a collection called Launch and add these 3 assets.

Copy the prompt

Copied

Show what we spent on fal models this week by endpoint.

SEE HOW AUTH WORKS

Each user connects their own Fal AI API key once, and Scalekit sends it with every call. Keys stay vaulted, every call is scope checked, and every action is logged.

Authorize

Your user connects

Fal AI

once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access

Who:

user ‘A’

when:

Once per user

access:

Limited to user

Store

Their

Fal AI

token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection

vault:

encrypted

scope:

per-user

tokens:

auto-refreshed

Resolve

When your agent calls a

Fal AI

tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs

speed:

~40ms

check:

before every call

seen by:

nobody

Audit

Every

Fal AI

tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it

history:

90 days

export:

SIEM-ready

logged:

every call

Test other agents

See the same per-user auth pattern across other AI and media connectors.

GTM and RevOps Teams

Competitive intelligence briefing agent

Scans Gong calls for competitor mentions, matches each one to its Notion battlecard, and DMs every affected rep a single Slack digest per cycle. Every call runs as the PMM who owns the briefing, never a shared bot.

Why Scalekit

Secure your agent's access. Connectors ship in minutes

01.

Shared tokens break per-user analytics

A shared Fal AI API key looks fine in a demo. In production every generation request looks like one service account, and you cannot tell which user triggered it. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.

// shared key
audit → bot_service_account

// scalekit
audit → user_abc ✓

02.

Authentication is not authorization

03.

Multi-tenancy is architectural

04.

Fal AI today. Ten connectors tomorrow.

“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”

Venu Madhav Kattagoni

Head of Engineering / Von

FAQs

Frequently Asked Questions

Does the agent access Fal AI as the user or through a shared API key?

As the user. Each user connects their own Fal AI API key once, and Scalekit sends it with every call. Audit logs attribute every generation request to that user, not a shared service account.

Where is the Fal AI API key stored?

In Scalekit's managed AES-256 token vault, namespaced per tenant. To rotate it, the user reconnects with a new API key. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.

Can I limit what the agent does in Fal AI?

Yes. Filter by tool name in listScopedTools to expose only what you want, for example model search, pricing, and request status without fal_run_model or fal_delete_request_payloads, which permanently deletes a request's stored inputs, outputs, and CDN files. Scalekit also enforces scope checks before every API call.

What happens when a user revokes Fal AI access?

The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.

What is the difference between running and queueing a request?

fal_run_model makes a direct blocking call and waits for the output. fal_submit_request queues the request and returns at once with a request id, which the agent polls with fal_get_request_status and reads with fal_get_request_result.