> For the complete documentation index, see [llms.txt](https://docs.fastn.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.fastn.ai/~/revisions/aj5eaS57qHvafrgYtfbL/fastn-v2/getting-started/what-is-fastn.md).

# What is Fastn

Fastn is an embedded integration platform that lets SaaS companies offer native integrations to their customers without building or maintaining connector infrastructure.

You embed Fastn into your product. Your customers connect their apps (Slack, HubSpot, Shopify, Xero, and others) through a branded widget inside your UI. Fastn handles authentication, data normalization, workflow execution, and monitoring behind the scenes.

### Who is Fastn for

Fastn is built for two audiences:

**SaaS companies (you)** — You have a product and your customers need integrations with third-party apps. You don't want to build and maintain connector infrastructure yourself. With Fastn, you configure which connectors to offer, build the automation workflows, and embed a branded integration hub into your product. You manage everything from the Fastn dashboard at `live.fastn.ai`.

**Your end users (your customers)** — The people who use your SaaS product. They interact with Fastn through the embedded widget inside your app — connecting their own accounts (their Slack workspace, their HubSpot instance, their Shopify store), activating integrations, and viewing sync status. They never see the Fastn dashboard or know that Fastn exists behind the scenes.

### What Fastn replaces

Without Fastn, SaaS companies typically face one of these situations:

* Building integrations in-house: a team maintains OAuth flows, API versioning, error handling, and data mapping for every third-party app per customer.
* Using an integration marketplace like Zapier or Make: works for simple triggers, but doesn't give you a native, branded experience inside your product. Your customers leave your UI to set things up.
* Hiring a systems integrator: expensive, slow, and creates a dependency on external consultants for every new connector.

Fastn replaces all of these with a single platform. You embed once, configure connectors and workflows, and every tenant gets isolated, working integrations with no additional engineering effort from your side. Built-in AI agents handle discovery, onboarding, workflow building, configuration, and operations monitoring — so your team spends less time on integration support.

### The three product areas

Fastn has three core product areas. Each solves a different integration problem:

#### Embedded Integrations (Widgets)

The customer-facing piece. A branded integration hub that lives inside your product. Your end users use it to connect their third-party accounts, manage active integrations, and trigger workflows — all without leaving your app.

Widgets come in three types:

* **Selection Flow** — lets your users pick which integrations they want to activate
* **Configuration Flow** — collects settings and preferences from your users during setup
* **Widgets Starter** — a pre-built integration hub template you can customize

> **📷 Screenshot needed:** Embedded widget as it appears inside a sample SaaS product — showing the integration hub with connect/disconnect buttons and app logos.

#### Flows (Workflow Engine)

The automation backbone. Flows define what happens when data needs to move between systems. A flow has a trigger (what starts it) and a sequence of steps (what it does).

Example: When a new order lands in Shopify, fetch the customer details, normalize the data, create an invoice in Xero, and send a confirmation to Slack.

Flows run on Fastn's infrastructure. They support scheduling, event-driven triggers, API-based invocation, and conditional logic. You build them visually in the flow editor or define them in TypeScript using the `@fastn/workflow` DSL.

> **📷 Screenshot needed:** Flow editor canvas showing a multi-step flow (e.g., Shopify trigger → data transform → Xero invoice creation → Slack notification) with the step picker panel visible.

> **🎬 GIF needed:** Short clip of building a simple flow — creating the flow, adding a step from the picker, connecting it on the canvas.

#### UCL — Unified Context Layer (MCP Server)

The AI integration layer. UCL exposes your Fastn connectors as tools that AI agents can invoke through the Model Context Protocol (MCP). If you're building AI features into your product, UCL lets your agents connect to 250+ enterprise apps with managed authentication and multi-tenant isolation.

Example: Your AI assistant needs to look up a customer's recent invoices in Xero and post a summary to Slack. UCL provides the tools — `fastn_search_entities`, `fastn_list_integrations`, `fastn_create_flow`, `fastn_get_event_history`, `fastn_get_usage_summary`, `fastn_get_integration_status` — so the agent can execute these actions without you writing connector code.

> **📷 Screenshot needed:** UCL MCP server configuration page or the tool list showing available MCP tools for a connected project.

### AI agents across the platform

Across all three product areas, Fastn uses AI agents powered by Anthropic Claude to reduce manual work. These aren't a separate product — they're built into the platform and assist with onboarding, building, testing, and operations.

15 specialized agents are available, organized by function:

**Onboarding & Intelligence**

| Agent                  | What it does                                                                                                |
| ---------------------- | ----------------------------------------------------------------------------------------------------------- |
| **SaaS Onboarding**    | Guides SaaS companies through platform setup — connectors, integration packs, widget configuration, go-live |
| **Tenant Onboarding**  | Helps end customers connect tools, map fields, configure syncs and automations                              |
| **Intelligence Brief** | Multi-agent graph that researches companies and produces integration strategy briefs                        |
| **Planner Agent**      | Analyzes integration requirements, asks clarifying questions, produces a build plan and test cases          |

**Building & Configuration**

| Agent                              | What it does                                                                            |
| ---------------------------------- | --------------------------------------------------------------------------------------- |
| **Connector Builder**              | Discovers and creates connectors with auth setup, API actions, and webhook events       |
| **Connector Agent (Orchestrator)** | Orchestrator-managed version of connector builder with handback support                 |
| **Workflow Builder**               | Builds workflows from a plan, binds triggers, validates against test cases              |
| **Workflow Agent (Orchestrator)**  | Orchestrator-managed version of workflow builder with handback support                  |
| **Event Builder**                  | Creates webhook events for connectors and configures subscribe/unsubscribe lifecycle    |
| **Configuration Agent**            | Probes live APIs to gather sample data, lets users define filter conditions and targets |

**API & Spec Management**

| Agent                     | What it does                                                                   |
| ------------------------- | ------------------------------------------------------------------------------ |
| **Spec Import Builder**   | Finds and imports machine-readable API specs (OpenAPI, Swagger, Postman, etc.) |
| **Manual Action Builder** | Creates API actions one-by-one from platform API docs when no spec exists      |

**Testing & Quality**

| Agent               | What it does                                                                |
| ------------------- | --------------------------------------------------------------------------- |
| **Test Case Agent** | Generates executable integration test cases for workflows                   |
| **Action Tester**   | Executes actions against real test connections and reports pass/fail        |
| **Action Fixer**    | Fixes broken actions using real API docs, applies schema and output patches |

> **🎬 GIF needed:** AI Agent in action inside the dashboard — e.g., using the Workflow Builder agent to create a flow via natural language chat.

> **📷 Screenshot needed:** Agent Builder interface showing the natural language input and generated agent output.

### How data flows through Fastn

> **🖼️ Diagram needed:** Visual flow diagram showing: Event source (webhook/schedule/API) → Event Pipeline → Flow Execution → CDM Normalization → Target System. Include tenant isolation boundary around the execution path.

Here's the path data takes through the platform:

1. **Event arrives** — A webhook fires from Shopify, a schedule triggers, or an API call hits your flow endpoint.
2. **Flow executes** — Fastn runs the steps you defined: fetch data, transform it, write to a target system.
3. **Data normalizes** — The Canonical Data Model (CDM) translates between different systems' data formats. A "customer" in Shopify maps to a "contact" in HubSpot maps to a "client" in Xero — Fastn handles the translation.
4. **Tenant isolation** — Every piece of data is scoped to a specific tenant. Your customers never see each other's data, credentials, or execution history.
5. **Monitoring** — Every execution is logged with status, duration, and step-level detail. You see it in the dashboard. Your customers see their own activity through the widget.

### What you need to get started

To start using Fastn, you need:

* A SaaS product where your customers need third-party integrations
* A Fastn account (sign up at [fastn.ai](https://fastn.ai/))
* Basic familiarity with REST APIs and webhooks (for flow configuration)
* Frontend capability to embed the widget (JavaScript snippet or React component)

No infrastructure setup required. Fastn runs as a managed service — you configure, Fastn executes.

***

**Next:** [Key Concepts & Terminology →](https://claude.ai/chat/key-concepts-and-terminology.md) — Learn the terms you'll encounter throughout the platform and documentation.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.fastn.ai/~/revisions/aj5eaS57qHvafrgYtfbL/fastn-v2/getting-started/what-is-fastn.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
