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

# Lovable connectors: Connect tools, services, and APIs

> Connect Lovable to external tools, services, and APIs. Choose between app + chat connectors, chat connectors, and app user connectors, or integrate any API.

<head>
  <script type="application/ld+json">
    {`{"@context": "https://schema.org", "@type": "FAQPage", "mainEntity": [{"@type": "Question", "name": "What integrations does Lovable support?", "acceptedAnswer": {"@type": "Answer", "text": "Lovable has a built-in catalog of connectors that can work as app + chat connectors (used by your published app and in the chat), chat connectors (context for Lovable while building), and app user connectors (each end user connects their own account). Beyond the catalog, Lovable can integrate any external API."}}, {"@type": "Question", "name": "What is the difference between the connection types in Lovable?", "acceptedAnswer": {"@type": "Answer", "text": "An app + chat connection runs on one shared credential and works in the chat and in your published apps. A chat connection (MCP server) is personal to you and only gives Lovable context while building. It is never part of the published app. An app user connection lets each end user of your published app sign in with their own account."}}, {"@type": "Question", "name": "Can Lovable integrate with any API?", "acceptedAnswer": {"@type": "Answer", "text": "Yes. Lovable can integrate with any external API, public or private. APIs without authentication can be called directly, while authenticated APIs are integrated securely using the built-in backend (Cloud), secrets, and Edge Functions to protect credentials."}}]}`}
  </script>
</head>

**Connectors** link Lovable to the external tools and services you already use, such as Slack, Notion, HubSpot, and Google Workspace. Browse the catalog, connect a tool once, and Lovable handles authentication, credentials, and requests for you.

All connectors live in one catalog. What changes is **how you connect it**. When you select a connector and click **Add connection**, you choose the connection type it supports:

| **Connection type**             | **What it does**                                                                                                                                                                                     | **Learn more**                                           |
| :------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------- |
| **App + chat connector**        | Adds capabilities and external services that your published app can call, like sending messages or reading data. Runs on one shared account, and Lovable can use it in the chat while you build too. | [App + chat connectors](/integrations/app-connectors)    |
| **Chat connector (MCP server)** | Personal to you. Lovable reads your own tool accounts as context while you build. Never part of the published app.                                                                                   | [Chat connectors](/integrations/chat-connectors)         |
| **App user connector**          | Each end user of your published app connects their own account, and the app acts with their permissions.                                                                                             | [App user connectors](/integrations/app-user-connectors) |

Not every connector supports every type. Each connector's page in the catalog shows the types it supports, and the **Add connection** button lists the available options.

For anything the catalog does not cover, you can [integrate any API](/integrations/any-api) or connect your own [custom MCP server](/integrations/custom-mcp).

<Info>
  **What is an API?**\
  API (Application Programming Interface) is a structured way for services or applications to communicate and share data with each other. It defines what you can ask for, what you’ll get back, and how to make the request.
</Info>

## Where to find connectors

All connectors live in one catalog, at [lovable.dev/dashboard?connectors](https://lovable.dev/dashboard?connectors). You can open it from:

* The Lovable dashboard sidebar navigation, under **Connectors**
* The `+` menu next to the prompt input on the dashboard when starting a new project

<Tip>
  For quick access from anywhere, use the [command palette](/introduction/project-search-and-find#command-palette) (Cmd+K on Mac, Ctrl+K on Windows/Linux) and search for connectors.
</Tip>

Inside a project, the **Project connectors** page gives you one place to see everything connected to that project. It shows the connections your app uses under **App connections**, and the MCP servers your project can access under **Chat connectors**. To browse the full catalog from there, select **All connectors**. You can open **Project connectors** from:

* The `+` menu next to the prompt input in the project chat
* The project name menu at the top of the editor, under **Project connectors**
* The project toolbar, under [**More → Connectors**](/features/projects/editor#the-more-menu)

## Which connection type do I need?

Use this table to pick the right connection type for what you're building:

| Use                                                          | If you want to                                                                                                                                                          |
| ------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [App + chat connector](/integrations/app-connectors)         | Give your published app a capability every visitor shares, like posting to your team's Slack or reading a Google Sheet. Lovable can use the connection in the chat too. |
| [Chat connector (MCP server)](/integrations/chat-connectors) | Let Lovable read your own Notion docs, Linear tickets, or Miro boards while it builds, without sharing your account with anyone or your app.                            |
| [App user connector](/integrations/app-user-connectors)      | Let each user of your published app sign in with their own account, like Gmail or Salesforce, and see only their own data.                                              |
| [Custom MCP server](/integrations/custom-mcp)                | Bring a tool the catalog doesn't cover into the chat, like an internal CRM or a private API with an MCP server.                                                         |
| [Any API](/integrations/any-api)                             | Add functionality to your published app from any external service, even one with no connector at all. Lovable writes the integration code for you.                      |

An app + chat connection already works in the chat, so you don't need a separate chat connection for a tool your app is connected to. Choose a chat connection when the tool only offers one, or when you want Lovable to read your own account without sharing a credential with your workspace or your app.

You can also combine types. For example, connect Notion as a chat connector to build from your own specs, and as an app + chat connector so the finished app reads and writes your team's Notion pages while people use it.

## Hosting, backend, and AI

Hosting, a backend, and AI are built into Lovable, so there is no external account to connect. Lovable [hosts your app](/features/hosting) and includes a [built-in backend (Cloud)](/features/cloud) with database, authentication, storage, and edge functions. For AI features, [Lovable AI](/features/ai) gives your app AI capabilities without API keys or external accounts. You manage both from the same Connectors catalog as everything else.

If you prefer to run your backend on [Supabase](/integrations/supabase), connect your own Supabase project instead.

## Managing connectors in your workspace

Workspace admins and owners control who can create connections for each connector, which is also how connectors are made available or disabled, and the defaults differ by plan. Who can use an individual connection is chosen by whoever creates it. See [Manage connectors in your workspace](/integrations/admin-controls) for the full picture, and [Integration security](/integrations/security) for how credentials are stored and how the connector gateway works.

Once a connector is available, any builder with permission can [create a connection and link it to a project](/integrations/app-connectors#create-a-connection).

## FAQ

<AccordionGroup>
  <Accordion title="What integrations does Lovable support?">
    Lovable has a built-in catalog of connectors covering payments, messaging, data, productivity, CRM, and more. Beyond the catalog, nothing is off limits:

    * [Custom MCP servers](/integrations/custom-mcp) bring any MCP-compatible tool into the chat as context.
    * [Any API](/integrations/any-api) can be integrated into your published app. Describe the API in a prompt and Lovable writes the integration.
    * [Cloud](/features/cloud) and [Lovable AI](/features/ai) cover backend and AI needs without any external service.
  </Accordion>

  <Accordion title="What is the difference between the connection types?">
    The difference is whose account is used and where the connection works:

    * An **app + chat connection** runs on one shared account. It works in the chat and in your published app, and everyone using the app shares it.
    * A **chat connection (MCP server)** uses your own account and is personal to you. Lovable reads it as context while building, and it is never part of the published app.
    * An **app user connection** belongs to each user of your published app. Every user signs in with their own account, and the app acts with their permissions.

    The [decision table](#which-connection-type-do-i-need) above shows when to pick each one.
  </Accordion>

  <Accordion title="Can Lovable integrate with any API?">
    Yes. Lovable can integrate with **any external API**, public or private. APIs without authentication can be called directly, while authenticated APIs are integrated securely using the built-in backend (Cloud), secrets, and Edge Functions to protect credentials. See [Integrate any API](/integrations/any-api).
  </Accordion>
</AccordionGroup>
