> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flowra.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Projects and API keys

> What a Flowra project is, what lives inside it vs an external user, and how to manage API keys.

A **project** is your main **workspace** in Flowra: the boundary for API keys, shared tool setup, MCP, and the container for all end users and their automations.

It is **not** your dashboard login, and it is **not** an [external user](/product/external-users). Your login can access several projects; each project has its own switcher entry, settings, and keys.

## What you can do inside a project

Almost the whole product runs inside the active project:

| Area                   | What you do                                                                                        |
| ---------------------- | -------------------------------------------------------------------------------------------------- |
| **Agents & workflows** | Build in chat or the editor; static graphs or conversational agents                                |
| **Tools**              | Use 20,000+ toolkit tools; create custom JS/Python tools; browse Toolkits & Tools                  |
| **Connections**        | OAuth-link Slack, Gmail, Telegram, and other apps (per end user)                                   |
| **Entry points**       | Dashboard chat, messaging channels, schedules, events, site [widgets](/product/widgets-and-embeds) |
| **Data**               | Knowledge (RAG), tables/database, files                                                            |
| **Skills**             | Attach reusable playbooks to agents                                                                |
| **MCP**                | Register servers; expose tools to Cursor / Claude                                                  |
| **Runtime**            | Sandbox code runs, live browser sessions                                                           |
| **Marketplace**        | Clone workflow templates into this project                                                         |
| **Multi-tenant**       | Many [external users](/product/external-users) under one project                                   |
| **API**                | Call the same capabilities with a project API key                                                  |

Credits and plan limits apply at account level; optional **own OpenRouter key** can be set per project on paid plans.

## Nested map: project vs external user

Everything sits under your **account**, then a **project**, then optionally many **external users**:

```text theme={null}
Your Flowra account (dashboard login)
└── Project  ← sidebar project switcher · one API key binds here
    │
    ├── Shared across the project (not “owned” by one end user)
    │   ├── Project settings (name, webhooks, branding, …)
    │   ├── Flowra API keys
    │   ├── Optional OpenRouter (BYOK) AI key
    │   ├── Auth configs (OAuth app / API key setup per toolkit)
    │   ├── Toolkits & custom tools (project LOCAL tools + catalog access)
    │   ├── MCP servers
    │   ├── Marketplace (browse; clone lands in this project)
    │   ├── External users directory (list / create usernames)
    │   ├── Trigger instances (schedule / event subscriptions)
    │   └── Files (project file library)
    │
    └── External user (eUID)  ← sidebar End user switcher · x-username on API
        ├── Connected accounts (that person’s Slack, Gmail, …)
        ├── Workflows & agents (ownerEUID) + executions
        ├── Skills
        ├── Knowledge collections (RAG)
        ├── Tables / database collections
        ├── Chat threads
        └── Tool runs that use this user’s connections
```

```mermaid theme={null}
flowchart TB
  Account[Flowra account login]
  Project[Project]
  Shared[Shared project setup]
  EU1[External user alice]
  EU2[External user bob]
  Account --> Project
  Project --> Shared
  Project --> EU1
  Project --> EU2
  Shared --> AuthCfg[Auth configs]
  Shared --> Tools[Tools and MCP]
  Shared --> Keys[API keys]
  EU1 --> CA1[Connections]
  EU1 --> WF1[Agents and data]
  EU2 --> CA2[Connections]
  EU2 --> WF2[Agents and data]
```

| Layer             | Pick with                        | Typical use                                            |
| ----------------- | -------------------------------- | ------------------------------------------------------ |
| **Account**       | Sign-in                          | Billing, pricing, support                              |
| **Project**       | Project switcher                 | Separate apps, environments (dev/prod), or departments |
| **External user** | End user switcher / `x-username` | Each customer or person inside one product             |

**Rule of thumb:** Use **another project** when you want a hard split (different API keys, tool setups, MCP). Use **another external user** when the same product should keep each person’s OAuth tokens and data apart.

Deep API matrix: [Multi-tenancy](/guides/multi-tenancy).

## Create and switch projects

<Steps>
  <Step title="Open projects">
    Use **Add project** on the switcher, or go to [Projects](https://flowra.dev/dashboard/projects).
  </Step>

  <Step title="Create">
    Open [Create project](https://flowra.dev/dashboard/projects/create). Enter at least a name (description optional) and submit.
  </Step>

  <Step title="Open settings">
    From the switcher gear or the projects list, open project settings for metadata, webhooks, branding, and **API keys** when shown.
  </Step>
</Steps>

After you select a project, pick the right **End user** before connecting accounts or testing chat — see [External users switcher](/product/external-users).

## Flowra API keys

API keys authenticate calls to the Flowra API for **one project**. One key cannot reach another project.

<Steps>
  <Step title="Open API Keys">
    In the project, open **Project → API Keys** (or the API keys tab in project settings).
  </Step>

  <Step title="Create a key">
    Create a key, give it a clear name (for example `Backend prod`), and copy it once. You will not see the full value again.
  </Step>

  <Step title="Store it securely">
    Keep the key in a secrets manager or environment variable. Do not commit it or expose it in client-side apps. For multi-tenant apps, your backend holds the key and sends `x-username` per end user.
  </Step>
</Steps>

How to send the key: [Authentication](/authentication). First request: [Quickstart](/quickstart).

## Credits and your own AI key

* Account and plan status: [Account](https://flowra.dev/dashboard/account) and [Pricing](https://flowra.dev/dashboard/pricing).
* On paid plans, project settings may let you paste an **OpenRouter** API key so model usage for that project bills through your OpenRouter account instead of platform credit. Create a key at [openrouter.ai/settings/keys](https://openrouter.ai/settings/keys). Free plans typically keep that field disabled until you upgrade.

## Related

* [How Flowra works](/product/how-flowra-works)
* [External users switcher](/product/external-users)
* [Toolkits and tools](/product/toolkits-and-tools)
* [Skills](/product/skills)
* [Entry points and channels](/product/entry-points-and-channels)
* [Multi-tenancy](/guides/multi-tenancy)
* [Authentication](/authentication)