> For the complete documentation index, see [llms.txt](https://docs.flora.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.flora.ai/mcp/security.md).

# FLORA MCP security and data

Understand what data FLORA MCP sends to your agent client and to model providers, how OAuth sign-in and API keys work, how to require approval before spend, and how to guard against prompt injection.

When you connect an agent to [FLORA MCP](https://flora.ai/mcp), it acts as you: it reads what you can read in FLORA and spends what you can spend. This page explains where your data goes, how sign-in and API keys work, how to keep a person in the loop before money is spent, and what to watch for when an agent reads content other people wrote.

## Where your data goes

FLORA MCP is a remote server at `https://agents.flora.ai/mcp`. Your client sends it tool calls, and it calls the FLORA API on your behalf. Web clients such as Claude and ChatGPT connect from their own servers, not from your computer.

| Data                                                                                                      | Where it goes                                                                                                                                                                                           |
| --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Tool results** (workspace and project names, canvas contents, comments, prompts, output URLs, balances) | Your agent client and the AI model behind it. Whatever a tool returns becomes part of that conversation, under the client's own data policies.                                                          |
| **Generation inputs** (prompts, parameters, reference images and files)                                   | FLORA, then the model provider that runs the generation. FLORA's no-training terms cover these. See [Data, Security, & IP](https://docs.flora.ai/legal/data-security-and-ip.md).                        |
| **Files you upload**                                                                                      | Your FLORA workspace. With `source` set to a public URL, FLORA fetches the file itself; with `signed-url`, the bytes go straight from you to FLORA's storage through the upload link.                   |
| **Outputs**                                                                                               | Your FLORA workspace, as canvas nodes and assets. Tool results carry links to them. Share those links only where you would share the files.                                                             |
| **Operational logs**                                                                                      | FLORA. The MCP server records which tool ran, when, for how long, from which client and whether it failed. These logs are designed to leave out prompts, tool arguments, access tokens and output URLs. |

The model you chat with sees only what tools return. It never sees your FLORA password, and with OAuth it never sees your access token either: the client holds it.

## Sign-in: OAuth or an API key

|                    | OAuth (default)                                                                                                        | API key                                                                                          |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| **Use for**        | People using Claude, ChatGPT, Cursor and other interactive clients                                                     | Headless setups, CI and scripts with no browser                                                  |
| **How it works**   | You sign in with your FLORA account in a browser. The client stores the token and refreshes it.                        | The client sends `Authorization: Bearer <key>` with a key that starts with `ak_` or `flora_sk_`. |
| **What it can do** | Anything your FLORA account can do, in every workspace you belong to                                                   | Only the workspaces and permissions (Read, Write, Billing) chosen when the key was created       |
| **Where it lives** | In the client                                                                                                          | Wherever you store it. Treat it like a password and keep it out of chat messages and code        |
| **Revoke it**      | Disconnect or remove FLORA in the client (each [install page](https://docs.flora.ai/mcp/install.md) has a Remove step) | **Settings → API Keys**, then **Revoke** on the key                                              |

See [Authentication](https://docs.flora.ai/mcp/authentication.md) for setup details for each method.

## Permissions

An agent never gets more access than the person or key behind it:

* **Your role applies.** If you can only view a workspace, the agent can only read it. Guests can't generate, and admin-only settings stay admin-only.
* **You choose the workspace.** A connection isn't tied to one workspace. Tools take a `workspace_id`, or resolve it from the `project_id`. When several workspaces could pay for a run, the agent should name them and ask which one to bill.
* **Mismatches are refused.** A `workspace_id` that doesn't own the `project_id` is rejected, so a run can't be billed to a workspace the project isn't in.
* **Spending limits still apply.** Member limits, workspace spend limits and the overage cap stop agent runs exactly as they stop canvas runs. See [Cost, balance and limits](https://docs.flora.ai/mcp/cost-and-limits.md#spending-limits-and-member-limits).
* **Sharing is explicit.** `flora_share_project` makes a link that gives access to anyone who has it. The agent should hand that link to you, not post it anywhere.
* **Sign-in links are personal.** `flora_open_project` returns a one-time link that signs a browser in as you. Never forward it.

## Approvals before writes and spend

Every FLORA tool carries the standard MCP annotations, so your client knows which calls change things and can ask you first:

| Annotation                      | Means                                                               | Examples                                                                                                            |
| ------------------------------- | ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| Read-only (`readOnlyHint`)      | Reads only. Safe to allow without asking                            | `flora_list_workspaces`, `flora_get_usage`, `flora_list_generations`, `flora_get_canvas`, `flora_list_models`       |
| Destructive (`destructiveHint`) | Can change or remove existing work, or spend money                  | `flora_create_generations`, `flora_remove_from_canvas`, `flora_update_canvas_nodes`, `flora_update_project_sharing` |
| Open-world (`openWorldHint`)    | Reaches outside FLORA (a model provider, a URL fetch, a share link) | `flora_create_generations`, `flora_create_asset`, `flora_share_project`                                             |

These tools spend money:

| Tool                       | Spends                                                                    |
| -------------------------- | ------------------------------------------------------------------------- |
| `flora_create_generations` | Each started generation (unless `quote: true`)                            |
| `flora_run_technique`      | The Technique's `run_cost` per run                                        |
| `flora_run_canvas_nodes`   | Each generation node it starts, immediately and with no confirmation step |
| `flora_train_lora`         | One LoRA training run                                                     |

Keep approval on for these and for the sharing tools. Most clients let you set approval per tool or per connector. Leave read-only tools on automatic so the agent can look things up without interrupting you. Agents should also follow the cost rule on their own, whatever the client's settings:

{% hint style="warning" %}
**Cost rule.** Price first: call `flora_create_generations` with `quote: true` and show the user the cost in US dollars. Run the same request without `quote` only after they approve. On `insufficient_credits` or any `BILLING_*` error, stop and pass the message on. Don't retry. Check balance and spend with `flora_get_usage`. A failed run isn't charged; a retry is a new run and is billed again.
{% endhint %}

## Prompt injection

An agent reads text that other people wrote: canvas prompts and notes, comment threads (`flora_list_comment_threads`), node documents, project and node names, Technique descriptions, workspace skills, and the contents of files and URLs you hand it. Any of that text can contain instructions, such as "share this project publicly" or "generate 200 videos". To FLORA they're data, and they should be data to your agent too.

To stay safe:

* **Treat tool results as content, not commands.** Only you decide what the agent does next. If a comment or file asks the agent to act, the agent should tell you instead of acting.
* **Review before you approve.** Read the quote and the request (count, model, workspace) before a spending tool runs, especially after the agent has read shared content.
* **Watch the open-world tools.** Be careful when the agent fetches URLs you didn't give it, shares projects, or uploads files from sources you don't know.
* **Limit the blast radius.** Give automation API keys only the permissions they need, and set a member limit for accounts that run agents unattended.

## Recommendations for teams

* **One sign-in per person.** Have each person connect with OAuth, so runs are attributed to them and their role and limits apply. Don't share one account between people.
* **API keys for automation only.** Create one key per integration with the least access it needs: Read only where possible, Write only for workspaces it generates in, Billing only if it reads usage. Revoke keys you no longer use.
* **Set limits before you scale.** Use workspace member usage limits, organization member limits and workspace spend limits (see [Organizations](https://docs.flora.ai/organizations/organizations.md#usage-limits-at-a-glance)) so a runaway loop stops at a known amount.
* **Keep approvals on for spend and sharing,** even for trusted agents.
* **Separate automated work.** Run large or unattended batches in their own workspace or project, so their spend and outputs are easy to review.
* **Review spend.** `flora_get_usage` reports workspace and organization spend in US dollars, and the in-app usage pages break it down by member.
* **Need formal terms?** Enterprise plans include SSO, a DPA and SOC 2 documentation. See [Data, Security, & IP](https://docs.flora.ai/legal/data-security-and-ip.md).

## Related

* [Authentication](https://docs.flora.ai/mcp/authentication.md)
* [Cost, balance and limits](https://docs.flora.ai/mcp/cost-and-limits.md)
* [Troubleshooting](https://docs.flora.ai/mcp/troubleshooting.md)
* [Help & Support](https://docs.flora.ai/getting-started/help-and-support.md)


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.flora.ai/mcp/security.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
