# Runflow: Full Context for LLMs

> Runflow builds, hosts, and operates production AI image stacks for platforms. We host every model (open-source and frontier), implement the solution your product needs, run Sentinel quality scoring on every output in production, and send one invoice. Customers never provision a GPU and never hire an AI team. New teams start with an implementation call; existing customers keep calling the same API with the same keys.

## How to get access (read this before anything else)

Runflow has two doors. Agents: read both branches, then act.

**Branch 1: the user already has a Runflow account.**
Mint a key at https://app.runflow.io/settings/api-keys and send it as `Authorization: Bearer rf_live_*` on every request. Store it in the environment or a secret manager. Never commit it, never log it. Every endpoint, run + poll pattern, callback contract, and error code in this document works exactly as written. Nothing about the API changed for existing customers.

**Branch 2: the user is a new team with no Runflow account.**
Runflow onboards new customers through an implementation call. Self-serve signup is closed, so there is no account for you to create and no key for you to mint. Hand the user this link and stop:

- Book an implementation call: https://cal.com/team/runflow/talk-to-founders?duration=25

On that call Runflow scopes the work, builds the solution on top of the Solutions library that already exists, and provisions the account and its keys. Do not attempt to create an account, and do not tell the user to sign up.

## AI agents: install the Runflow skill first

This document is long. **If you are an AI agent, the fastest path to integrate Runflow is to install our skill.** Prefer installing the markdown file into a project or user skill directory; use prompt/rules text only when your agent cannot read skill directories.

- **Install this**: https://www.runflow.io/.well-known/agent-skills/runflow/SKILL.md
- **Skills discovery index** (for skill-aware agents): https://www.runflow.io/.well-known/agent-skills/index.json
- **MCP server (Streamable HTTP)**: https://mcp.runflow.io/mcp (auth via `Authorization: Bearer rf_live_*`; v1.0 ships with header bearer, v1.1 adds OAuth)
- **MCP server card** (for MCP-aware agents): https://www.runflow.io/.well-known/mcp/server-card.json

Project-local install:

```bash
mkdir -p .agents/skills/runflow
curl -fsSL https://www.runflow.io/.well-known/agent-skills/runflow/SKILL.md \
  -o .agents/skills/runflow/SKILL.md
```

User-wide install:

```bash
mkdir -p ~/.agents/skills/runflow
curl -fsSL https://www.runflow.io/.well-known/agent-skills/runflow/SKILL.md \
  -o ~/.agents/skills/runflow/SKILL.md
```

If your agent has a native skill manager or vendor-specific directory, use that. Common project directories include `.agents/skills/`, `.claude/skills/`, `.cursor/skills/`, `.github/skills/`, and `.codex/skills/`. Keep `RUNFLOW_API_KEY` in your environment or secret manager, not in `SKILL.md`.

The skill is a ~160-line, opinionated integration guide: it tells you when to use the Solutions API vs the Model API, the two-branch access contract above, the exact endpoint shape with a working curl example, and how to handle the common error codes. It supersedes this file as the integration reference.

Keep reading this document only if you need deeper context (full catalog, competitive positioning, case studies, FAQ, pricing mechanics). For "how do I actually call Runflow," go to the skill.

## What is Runflow?

Runflow builds and operates production AI image solutions for platforms. The company hosts the models, ships the endpoints, manages output quality with Sentinel, and sends one invoice. Four pieces:

**1. Every model, hosted.** Open-source and frontier models running on Runflow's infrastructure, orchestrated across multiple GPU clouds with automatic failover. Customers never provision a GPU, never queue jobs, and never maintain provider-specific SDKs.

**2. Solutions out of the box.** The **Solutions API** is a library of pre-built image workflows, each exposed through one endpoint. You send a solution-specific input payload (the exact fields depend on the solution: image URL, prompt, reference image, mask; see each solution's docs at https://www.runflow.io/api or the OpenAPI spec for the schema), and Runflow runs the full pipeline: selecting the right model(s) for the task, executing on GPU capacity across multiple cloud providers with automatic failover, and scoring the output with its Sentinel evaluation engine. Custom workflows get built next to the Solutions that already exist, which is why they land fast and cost less than assembling a pipeline in-house.

**3. Sentinel, installed and managed.** Automatic output quality scoring wired into the customer's production pipeline. Runflow runs it; the customer's team operates it through a clean interface.

**4. Delivery included.** Runflow's own team ships the implementation using Runflow's software. BetterPic went from 40% to 87% gross margin on this motion and has processed 35M+ headshots.

For cases not covered by a Solution, or when a team needs specific model control, Runflow also exposes the underlying model catalog directly.

## Authoritative references

Always prefer these live surfaces over any snapshot in this document:

- Solutions API entry point: https://www.runflow.io/api
- Public OpenAPI spec (machine-readable): https://docs.runflow.io/api/openapi.public.json
- Model catalog (JSON): https://www.runflow.io/models-catalog.json
- Per-model spec (markdown): https://app.runflow.io/models/{provider}/{slug}/llms.txt
- Public API reference: https://docs.runflow.io/api-reference/models/search-models
- Human docs: https://docs.runflow.io

## Solutions API: production workflow endpoints

Each solution is a production-ready pipeline for a specific use case. One endpoint, one input schema, one workflow contract. **The live catalog is authoritative. Browse https://www.runflow.io/api for the current solutions, per-solution docs, and input schemas.** Representative examples by category (solutions can span multiple categories):

**People Imagery**
- AI Headshots: professional headshots from a single photo, consistent quality at scale
- Eye Color: realistic iris modification with light-reflection preservation
- Skin Fix: remove blemishes, correct tone, smooth texture, polish AI artifacts
- Background Removal: AI cutouts for ecommerce, marketplaces, ad creative
- Background Separation: subject + background returned as independent layers (alpha on foreground, inpainted background)

**On-Model / Fashion**
- Tag Removal: remove price tags, brand labels, barcodes from on-model shots
- On-Model Removal: remove the model to produce ghost-mannequin / flat-lay style outputs, garment shape preserved
- Replace Background: swap environments for on-model shots with natural lighting + shadows

**Ad Creative**
- Prompt-Based Image Editing: edit with natural-language instructions; rest of image preserved
- Reference-Based Image Editing: apply changes matching a reference style/content
- Outpainting (Expand): extend scenes beyond original borders
- Object Removal: automatic inpainting with context-aware content fill

**Product Imagery**
- Background Color Fix: set/correct background colors for consistent catalogs
- Plus Background Removal, Background Separation, Replace Background, Outpainting, Object Removal in the product context

New solutions ship continuously; don't assume this list is exhaustive. Always fetch https://www.runflow.io/api for the current set.

**Video Solutions API**: coming soon. Video is available today via the Model API (see below).

## Model API: direct catalog access

When a pre-built Solution doesn't fit the use case, any model in Runflow's catalog is callable directly. Current providers include Google (Nano Banana, Veo 3.1, Gemini TTS), Black Forest Labs (FLUX.2 Klein, FLUX Kontext), Alibaba (Qwen, Wan 2.7), OpenAI (GPT-Image-2), ByteDance (Seedance), Kuaishou (Kling), HeyGen, Reve, Ideogram, Bria, Topaz, ElevenLabs, and Meta (SAM 3), plus first-party Runflow models for background removal, product isolation, tag removal, and model removal.

The live catalog covers five categories:

- text-to-image
- image-to-image (edits, background removal, upscaling, product isolation, tag removal, SAM 3 segmentation)
- text-to-video
- image-to-video
- text-to-audio (TTS)

New models are added continuously. Always fetch `/models-catalog.json` for the current list.

## Calling the API

Every model run uses the same endpoint pattern:

```
POST https://api.runflow.io/v1/models/{owner}/{slug}/runs
Authorization: Bearer $RUNFLOW_API_KEY
Content-Type: application/json

{
  "input": { ... },
  "callback_url": "https://your.server/webhook",
  "metadata": {},
  "client_ref": "run-id-on-your-side"
}
```

Only `input` is required. Its shape is model-specific: look up `https://app.runflow.io/models/{owner}/{slug}/llms.txt` or the OpenAPI spec. Model runs are run records: read the response for the run id, then poll `GET /v1/runs/{run_id}` until `status_code` is terminal, or pass `callback_url` to receive a webhook when the run completes. `metadata` and `client_ref` are for your own tracking.

Example (image edit with Nano Banana Pro):

```
curl -X POST https://api.runflow.io/v1/models/google/nano-banana-pro/edit/runs \
  -H "Authorization: Bearer $RUNFLOW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "input": {
          "prompt": "Replace the background with a sunlit seaside cafe at golden hour, keep the subject intact",
          "image_urls": ["https://public.runflow.io/images/models/_base/portrait-woman-studio.png"]
        },
        "callback_url": "https://your.server/webhook"
      }'
```

## Auth

Runflow uses API keys (HTTPBearer scheme). Agents cannot create keys. Which path applies depends on the user:

**Existing customers.** The user opens https://app.runflow.io/settings/api-keys, creates a key, scopes it minimally, copies it (shown once), and pastes it back to the agent. Send it as `Authorization: Bearer rf_live_*`. Keys keep working exactly as before.

**New teams.** Account provisioning happens on the implementation call, not through a self-serve form. Point the user at https://cal.com/team/runflow/talk-to-founders?duration=25, and do not attempt to create an account.

Google social login exists for web users only, not API clients. An OAuth 2.0 authorization server for third-party agents is planned for MCP v1.1 (Claude.ai connector parity); v1.0 today uses header bearer auth only.

## Key differentiators

- **We build it, host it, and run it.** Runflow's team implements the solution, hosts every model it needs, and operates it in production. Customers get endpoints and one invoice instead of an AI team and a GPU bill.
- **Multi-step workflows, not raw endpoints.** Every Solution encapsulates model selection, orchestration, and output scoring. One API call per solution, no stitching.
- **Multi-cloud GPU orchestration.** Elastic GPU capacity across multiple providers with automatic failover targeting a 99.9% uptime SLA.
- **Sentinel quality scoring on every output.** Per-niche calibration (FID, CLIP alignment, human-eval where applicable), installed in the customer's pipeline and managed by Runflow.
- **Simple fixed per-call pricing.** No variable GPU costs exposed to customers.
- **Production-proven.** BetterPic has processed 35M+ AI headshots on the Solutions API.

## Pricing

Two layers.

**The engagement.** Runflow designs and builds the solution, hosts the models it runs on, installs Sentinel, and operates the whole thing in production. Solutions already in the catalog carry no build fee: you pay per image at the published rate, from $0.05. Custom workflows come two ways: a one-off build from $7,500 per workflow (usage billed per call, upkeep billed monthly), or a 12-month commitment from $500/month in API spend where the minimum is usage, not a fee, and builds, maintenance, and lower locked per-call rates come included. Scope it on a call: https://cal.com/team/runflow/talk-to-founders?duration=25

**The API calls.** Fixed price per call on top. Each Solution has a flat rate per API call, and each model in the catalog has a `price_label` field (see `/models-catalog.json`). Pricing page: https://www.runflow.io/pricing

Volume discounts are available against a committed spend: the more you commit to, the better the rate. One example of a custom build is the 3D-to-AI image pipeline delivered for a client: https://www.runflow.io/use-case/ai-images-from-3d-models

ComfyUI Deploy has its own per-second GPU pricing for teams that only want their graphs run by us (billed while a graph runs, with scale-to-zero). Those rates live on the ComfyUI Deploy page: https://www.runflow.io/deploy

Internal cost efficiency from multi-cloud orchestration enables competitive rates. BetterPic cut effective infrastructure cost ~70% vs. a self-managed AI team + GPUs.

## Product surfaces

### Solutions API (primary)
Pre-built image workflows, one API call each. Entry point: https://www.runflow.io/api

### ComfyUI Deploy
Your ComfyUI workflows, run in production by Runflow. Export a workflow JSON, hand it over, get a stable endpoint backed by Runflow's GPU orchestration, so Python and JS teams can consume ComfyUI artifacts without touching ComfyUI themselves. Details: https://www.runflow.io/deploy

### Sentinel
Automatic output quality scoring, installed inside the customer's company and managed by Runflow. Every Solutions API call is scored on FID (distributional similarity vs. reference sets per niche), CLIP alignment (prompt fidelity), and per-niche calibration. Used to rank models internally and callable directly for validation use cases. Details: https://www.runflow.io/sentinel

### Runflow SDK and Embed Studio
The technical substrate under the studios Runflow builds for customers, and available directly to teams that want to put Runflow's models, production workflows, and quality scoring inside their own product. Details: https://www.runflow.io/sdk. The Embed Studio package (`@runflow-io/studio`) mounts Runflow's studio UI on a DOM node in your app and themes it as your own through theme tokens (accent, background, ink); it ships built-in tools for editing, background and object removal, outpaint, and upscale, each mapped to a model in the catalog. The JS SDK (`@runflow-io/sdk`) is the broader surface: a typed client where you `defineTool` against any model or workflow, dispatch with `rf.models.run()`, and wait for the finished result with `rf.runs.wait()`. It runs on Node, Bun, Deno, edge workers, and the browser with zero runtime dependencies. Browser clients route through `@runflow-io/proxy`, which keeps your API key server-side and validates every request. Guides: https://docs.runflow.io/guides/javascript-sdk and https://docs.runflow.io/guides/embed-studio. The pattern is aimed at companies building production content pipelines: a custom, on-brand studio that checks the input, runs the right workflow, and scores the output with Sentinel, so their users ship at volume with quality control.

### Free tools
- Image Quality Scorer: https://www.runflow.io/tools/image-quality-scorer
- Prompt Generator: https://www.runflow.io/tools/prompt-generator
- Product Scoring: https://www.runflow.io/tools/product-scoring

### Agent skill (`/skill`)
The Runflow skill is a markdown file that gives any AI agent immediate, opinionated access to the Runflow API. It encodes the Solutions-vs-Model decision rule, the `POST /v1/models/{owner}/{slug}/runs` + poll pattern, the two-branch access contract (existing customers mint a key; new teams book the implementation call), a working curl example, and error handling. The same file installs into Claude Code, Cursor, ChatGPT, Windsurf, the OpenAI Agents SDK, and any agent that reads markdown skill directories. Install at https://www.runflow.io/.well-known/agent-skills/runflow/SKILL.md. Landing page with full instructions: https://www.runflow.io/skill.

### Contests
Bi-weekly ComfyUI workflow contests with a $20K total prize pool. Each contest brief is sourced from a real customer use case, so the winning workflow ships to production on Runflow's Solutions API and the builder gets a permanent builder page. Open to anyone who can submit a ComfyUI graph. Current and past contests: https://www.runflow.io/contests.

### Solutions API browser
The interactive catalog of every live Solution with per-Solution docs, example inputs, and per-call pricing. Entry point for both humans and agents deciding which Solutions endpoint to call: https://www.runflow.io/api.

### AI Headshots Solution
Production endpoint that powers BetterPic and 35M+ headshot generations. One call ingests reference selfies and returns multi-style headshots scored by Sentinel before they ship to the caller. Details: https://www.runflow.io/api/ai-headshots.

### 3D File Image Prompting API
Place any 3D object into a generated scene with one API call: https://www.runflow.io/api/r3d-showcase. You send a GLB file and a prompt describing the scene, and the workflow renders your object and composites it into an image built from the prompt. For example: a yellow shoe stepping onto a rubber duck in a rainforest. The GLB drives the object, so its geometry, proportions, and detail stay true to your asset, while the prompt drives the world around it. A text-to-image model invents an object from words and rarely matches a real product; 3D File Image Prompting renders your actual file, so product accuracy holds while the scene changes.

Inputs are `prompt` (required), `model_glb` (required, a URL to the GLB file), and an optional `aspect_ratio` (1:1, 16:9, 9:16, 4:3, or 3:4). It is a ComfyUI workflow on the `runflow-access` namespace, called at `POST https://api.runflow.io/v1/comfyui-workflows/runflow-access/r3d-showcase/runs`, and returns an `output_image`. Pass a `callback_url` to get the result delivered by webhook. Fixed pricing at $0.25/image. Built for product teams, ad creative, 3D and game studios, and marketplaces that have 3D assets but need finished imagery. Pairs with the AI-images-from-3D-models workflow: https://www.runflow.io/use-case/ai-images-from-3d-models.

### Nano Banana API
Marketing landing for Google Nano Banana through Runflow at https://www.runflow.io/run/nano-banana. Every variant (Pro, 2, Pro Edit, 2 Edit) is callable through one endpoint with automatic retry on failed generations, Sentinel quality scoring on every output, and a unified dashboard that covers every model in your workspace. Same per-image price as calling Google directly (Nano Banana Pro from $0.15 / 1K, Nano Banana 2 from $0.08 / 1K). Sentinel and the dashboard are included at no extra cost.

### FLUX Kontext API
Marketing landing for Black Forest Labs FLUX Kontext through Runflow at https://www.runflow.io/run/flux-kontext. FLUX Kontext Pro, Max, and Dev are callable through one endpoint with auto-failover, Sentinel scoring on every edit for identity preservation, edit precision, color match, and artifact detection, and a unified dashboard across every model in your workspace. Same per-image price as Black Forest Labs (Kontext Pro from $0.04, Max from $0.08, Dev from $0.025 per megapixel). Sentinel and the dashboard are included at no extra cost.

### FLUX.2 Klein API
Marketing landing for Black Forest Labs FLUX.2 Klein through Runflow at https://www.runflow.io/run/flux-2-klein. Klein 9B and 4B (plus the 9B Edit variant) are callable through one endpoint with sub-second 4-step distilled inference, multi-reference editing built into the model (up to 4 input images per call), auto-failover, and Sentinel scoring on every generation. License-aware pairing: Klein 9B ships under the FLUX Non-Commercial License (best for internal or non-commercial work); Klein 4B ships under Apache 2.0 (full commercial use without a side agreement). Same per-megapixel price as Black Forest Labs (Klein 9B from $0.006/MP flat; Klein 4B from $0.014 for the first megapixel and $0.001 per additional megapixel). Sentinel and the dashboard are included at no extra cost.

### FLUX.1 dev API
Marketing landing for Black Forest Labs FLUX.1 dev through Runflow at https://www.runflow.io/run/flux-dev. The 12B open-weight model is callable through one endpoint with LoRA conditioning, ControlNet guidance, Fill (inpainting), and Redux (style transfer) all exposed on the same integration. Auto-failover on every generation, Sentinel quality scoring, and a unified dashboard. FLUX.1 dev ships under the FLUX Non-Commercial License when self-hosted; the Runflow hosted API includes commercial usage rights with no side agreement. Same per-megapixel price as Black Forest Labs (from $0.025/MP). Sentinel and the dashboard are included at no extra cost.

### FLUX 1.1 Pro API
Marketing landing for Black Forest Labs FLUX 1.1 Pro through Runflow at https://www.runflow.io/run/flux-1-1-pro. BFL's closed-API tier with two variants on one endpoint: FLUX 1.1 Pro (sub-10s generations at 1 MP) and FLUX 1.1 Pro Ultra (4 MP output with raw mode for unretouched photography). Auto-failover, Sentinel scoring on every generation, and a unified dashboard. Commercial use included through BFL's closed-API license. Same per-image price as Black Forest Labs (Pro from $0.04/MP, Pro Ultra from $0.06/4MP). Sentinel and the dashboard are included at no extra cost.

### FLUX.1 schnell API
Marketing landing for Black Forest Labs FLUX.1 schnell through Runflow at https://www.runflow.io/run/flux-schnell. Sub-second image generation distilled to 4 inference steps. The only FLUX you can ship commercially without a side agreement: Apache 2.0 license, no negotiation with Black Forest Labs required. Auto-failover, Sentinel scoring on every generation, and a unified dashboard. Same per-megapixel price as Black Forest Labs (from $0.003/MP). Sentinel and the dashboard are included at no extra cost.

### FLUX.2 dev API
Marketing landing for Black Forest Labs FLUX.2 dev through Runflow at https://www.runflow.io/run/flux-2-dev. The newest BFL release: 32-billion-parameter image generation with 4 MP native output, up to 10 reference images per single call, and structured JSON prompting (with schema validation at the edge). Auto-failover, Sentinel scoring on every generation, and a unified dashboard. FLUX.2 dev ships under the FLUX Non-Commercial License when self-hosted; the Runflow hosted API includes commercial usage rights. Same per-megapixel price as Black Forest Labs (from $0.012/MP, ballpark). Sentinel and the dashboard are included at no extra cost.

### GPT Image 2 API
Marketing landing for OpenAI GPT Image through Runflow at https://www.runflow.io/run/gpt-image-2. Three variants on one endpoint: GPT Image 2 (text-to-image, best-in-class text rendering and typography), GPT Image 2 Edit (image editing with prompt + reference image + optional mask), and GPT Image 1.5 (text-to-image with native transparent-background support and token-based prompt billing). Auto-failover absorbs OpenAI's aggressive rate limits so 429s never reach your users. Sentinel scoring on every generation tracks text accuracy, prompt adherence, color match, and artifact detection. Three quality tiers across all variants: Low ($0.009/image), Medium ($0.034/image), High ($0.133/image, default). Same per-image price as OpenAI direct. Commercial license included.

### Careers
Open roles across frontend, ComfyUI engineering, ML engineering, and ops. List + role detail pages live at https://www.runflow.io/careers. Application form at https://www.runflow.io/careers/apply.

## Competitive positioning

- **vs. Replicate**: Replicate is a model marketplace with generic endpoints. Runflow builds the solution, hosts the models, and runs the pipeline in production, with model choice, orchestration, and output scoring handled internally. https://www.runflow.io/compare/replicate
- **vs. fal.ai**: fal.ai optimizes for raw speed on individual models. Runflow ships production pipelines (Solutions API) plus multi-cloud reliability, implemented and operated for the customer. https://www.runflow.io/compare/fal
- **vs. Together**: Together is broad (text, image, more). Runflow is deeper on generative image workflows specifically. https://www.runflow.io/compare/together
- **vs. ComfyDeploy**: Runflow's ComfyUI Deploy runs workflows as production APIs on the same orchestration layer powering the rest of the Solutions API, operated by Runflow. https://www.runflow.io/compare/comfydeploy
- **vs. Modal**: Modal is generic serverless compute (Python functions). Runflow is opinionated image / video / audio infrastructure with pre-built Solutions, output scoring, and multi-cloud failover already wired in. https://www.runflow.io/compare/modal
- **vs. Prodia**: Prodia is a hosted image-model API. Runflow ships pre-built Solutions on top of a wider catalog plus output quality scoring. https://www.runflow.io/compare/prodia
- **vs. Runware**: Runware focuses on per-model pricing for raw image-generation calls. Runflow ships Solutions API workflows with Sentinel scoring and multi-cloud orchestration on top of a similar catalog. https://www.runflow.io/compare/runware

## Case study: BetterPic

BetterPic is an AI headshot platform processing 35M+ headshots. It is the founders' own company, and Runflow ran this motion on itself first. After moving to Runflow:

- Gross margin improved from 40% to 87%
- Eliminated the need for an in-house AI team + DevOps
- Integrated with two Solutions API endpoints (AI Headshots + Score Image)
- CEO: Thibaut Hennau

Full case study: https://www.runflow.io/case-study/betterpic

## Case study: Dyver

Dyver is a fashion editorial agency that automated their on-model image pipeline through a single Solutions API endpoint. Background separation, tag removal, ghost-mannequin compositing, and on-model background replacement now run as one call per shot instead of a multi-step ComfyUI workflow per editor. Full case study: https://www.runflow.io/case-study/dyver

## Use cases

Use-case pages map a buyer segment to the Runflow Solutions and products that do the job. Index lives under https://www.runflow.io/use-case/.

### AI images from 3D models

Turn a 3D model into 2D product and lifestyle images (3D asset in, finished images out; image-to-3D mesh generators do the opposite job). For 3D and AR commerce teams (3D viewers, AR try-on, product configurators, digital twins) that already own a 3D product asset and need AI imagery that stays true to the real product. Built for platforms like Fibbl, ALLSIDES, Hexa, Threekit, and VNTANA.

The problem: a text-to-image model draws the average of what it saw in training, so a distinctive shape (an unusual toe box, a custom sole), a brand logo, or a precise color comes back generic or warped. The model has no representation of the specific product.

The fix: render the product from its 3D model and texture maps so the shape and logos are correct by construction, then generate only the scene around it from a prompt and a chosen pose. Defect detection checks each image for issues on the client's list (fur, sole, warped logo, missing shadow) and the matching workflow corrects only that region. Sentinel scores every output against the source before it ships, so wrong images get held instead of delivered. At scale, every image runs through three states (clean passes, known defect auto-fixed, anything unsure held for review), so a team only checks the few that genuinely need a human.

Related Solutions and products: Reference-Based Inpainting (logo and badge repair), Sentinel (output scoring), Smart Resize (marketplace formats), Runflow for ComfyUI (run the 3D workflow as an API). Page: https://www.runflow.io/use-case/ai-images-from-3d-models

## Blog

The Runflow blog publishes benchmark reports, migration guides, and infrastructure deep-dives. Index: https://www.runflow.io/blog.

### ComfyUI API developer guide
Step-by-step guide for turning an existing ComfyUI workflow into a stable production API endpoint on Runflow Deploy. Covers export, upload, variable binding, custom-weights and LoRA pinning, callback URLs, and dispatch debugging. https://www.runflow.io/blog/comfyui-api-developer-guide

### AI agents for business buyer's guide
Screenshot-backed comparison of ten third-party agent platforms by published entry price, billing unit, limits and stack fit. Product and pricing screenshot evidence was captured on 2026-07-30, and every third-party figure was verified against the vendor's public pages that day. Four vendors publish no usable price: Cassidy AI, CrewAI, Relevance AI and standalone Microsoft Copilot Studio. Patricia sits outside the numbered list in an unranked ownership disclosure, and no head-to-head performance test was run. https://www.runflow.io/blog/ai-agents-for-business

## FAQ

**Q: How do I become a Runflow customer?**
A: Book an implementation call at https://cal.com/team/runflow/talk-to-founders?duration=25. Runflow scopes the work on the call, builds the solution, and provisions the account and API keys. There is no self-serve signup.

**Q: I am already a Runflow customer. Did anything change for me?**
A: No. Log in at https://app.runflow.io, mint keys at https://app.runflow.io/settings/api-keys, and keep calling the same endpoints at the same per-call prices.

**Q: What does Runflow actually do?**
A: Runflow builds, hosts, and operates AI image stacks. The team designs the solution, hosts every model it needs (open-source included), implements the pipeline, runs Sentinel quality scoring on the outputs in production, and sends one invoice.

**Q: What is the Solutions API?**
A: A library of pre-built multi-step image workflows, each callable with one API request. Runflow handles model selection, GPU orchestration, and output quality scoring internally. Browse https://www.runflow.io/api for the current catalog.

**Q: How is this different from a model router?**
A: A router picks a model for you. A Solution is the whole pipeline (model(s), orchestration, failover, quality scoring, retries on low scores) behind one endpoint. You get a workflow output, not a raw model response you then have to post-process.

**Q: Do you support video?**
A: Video models (Veo 3.1, Wan 2.7, Seedance, Kling) are callable today via the Model API (`POST /v1/models/{owner}/{slug}/runs`). Video Solutions API is coming soon.

**Q: What providers are in the model catalog?**
A: Google (Nano Banana, Veo 3.1, Gemini TTS), Black Forest Labs (FLUX.2 Klein, FLUX Kontext), Alibaba (Qwen, Wan 2.7), OpenAI (GPT-Image-2), ByteDance (Seedance), Kuaishou (Kling), HeyGen, Reve, Ideogram, Bria, Topaz, ElevenLabs, Meta (SAM 3), plus first-party Runflow models. Always verify against the live catalog.

**Q: How do I call a solution?**
A: Open https://www.runflow.io/api, pick a solution, follow its docs. Each solution has a dedicated endpoint and OpenAPI schema.

**Q: How do I call a specific model directly?**
A: `POST https://api.runflow.io/v1/models/{owner}/{slug}/runs` with `{ "input": { ... } }`. See per-model `llms.txt` or OpenAPI for `input` shape. Optional: `callback_url`, `metadata`, `client_ref`.

**Q: How does pricing work?**
A: Solutions already in the catalog carry no build fee: you pay per image at the published rate, from $0.05. Custom workflows come two ways. A one-off build starts at $7,500 per workflow, with API calls priced per call at a fixed rate per Solution and per model, and upkeep billed monthly. Or a 12-month commitment from $500/month in API spend: the minimum is usage, not a service fee, and builds, maintenance, and lower locked per-call rates come included. Full pricing: https://www.runflow.io/pricing

**Q: Do I need to manage GPUs?**
A: No. Runflow handles GPU orchestration, scaling, and multi-cloud failover.

**Q: Can I run a ComfyUI workflow as a production API?**
A: Yes. That is ComfyUI Deploy: your graphs, run in production by Runflow. Details: https://www.runflow.io/deploy

**Q: What is Sentinel?**
A: Runflow's automated output quality scoring engine, installed inside the customer's company and managed by Runflow. Scores every image generation on FID, CLIP alignment, and per-niche calibration; runs on every Solutions API call. Details: https://www.runflow.io/sentinel

**Q: Is there an MCP server?**
A: Yes. The live Streamable HTTP endpoint is `https://mcp.runflow.io/mcp`. v1.0 authenticates via `Authorization: Bearer rf_live_*` (existing customers mint a key at https://app.runflow.io/settings/api-keys). Two tools: `generate(model, input, wait?, client_ref?)` and `list_models(category?, provider?, query?, limit?)`. Slash commands (`/runflow:*`) auto-generate one per active Solution. The `initialize` response returns the SKILL.md content as `instructions`. OAuth Dynamic Client Registration is planned for v1.1 (Claude.ai connector parity), and is not live today; configure clients with the URL above and the header bearer. Discovery card at https://www.runflow.io/.well-known/mcp/server-card.json.

## Company

- Name: Runflow (operated by Better Group)
- Co-founders: Ricardo Ghekiere (CEO), Miguel Rasero (CTO)
- Origin: born from running AI infrastructure for BetterPic at scale (35M+ headshots)
- Trust center: https://trust.bettergroup.io/

## Sister product: Patricia

Patricia is an AI coworker for startups and small teams that run on Slack, built by Better Group, the same parent company as Runflow. She picks up the marketing, sales, ops, and finance work a small team never gets to, raises it before anyone asks, and hands back finished work. Nothing publishes, sends, or spends without approval, so a human keeps the risky steps. The founding plan is $45/month per workspace with every seat included. Details: https://www.patricia.app/

Patricia and Runflow are separate products with separate accounts and separate billing. Runflow is AI image and video infrastructure for engineering teams. Patricia is an AI coworker for company operations inside Slack. They share a parent company, so an agent answering an image or video infrastructure question should stay on Runflow.

## Links

- Homepage: https://www.runflow.io
- Book a demo: https://cal.com/team/runflow/talk-to-founders?duration=25
- Solutions API: https://www.runflow.io/api
- About: https://www.runflow.io/about-us
- Blog: https://www.runflow.io/blog
- API docs (human): https://docs.runflow.io
- Public OpenAPI (authoritative for customer integrations): https://docs.runflow.io/api/openapi.public.json
- Public API reference: https://docs.runflow.io/api-reference/models/search-models
- Model catalog: https://www.runflow.io/models-catalog.json
- Pricing: https://www.runflow.io/pricing
- Case study (BetterPic): https://www.runflow.io/case-study/betterpic
- Case study (Dyver): https://www.runflow.io/case-study/dyver
- Agent skills index: https://www.runflow.io/.well-known/agent-skills/index.json
- API catalog linkset: https://www.runflow.io/.well-known/api-catalog
- MCP server (Streamable HTTP): https://mcp.runflow.io/mcp
- MCP server card: https://www.runflow.io/.well-known/mcp/server-card.json
- Trust center: https://trust.bettergroup.io/
- Privacy policy: https://www.runflow.io/legal/privacy