> ## 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.

# Connect your app to Perplexity

> Connect your app to Perplexity, an AI search and answer engine, to return cited answers from live web, academic, and financial sources.

export const connector_0 = "Perplexity"

[Perplexity](https://www.perplexity.ai/) is an AI search and answer engine that returns concise answers grounded in live web data and backed by sources. The Perplexity connector lets your Lovable app call the Perplexity API with a shared API key. It's designed for apps that need fresh, source-backed information rather than static or training-only knowledge.

Perplexity is available as an [app + chat connector](/integrations/app-connectors): one shared connection that works in the chat while you build and in your published apps.

With Perplexity, your app can:

* Answer questions with current information from the web and cite the sources
* Search only academic papers or only SEC filings when a question calls for it
* Turn a single question into a long-form research report
* Pick a faster or a more thorough model for each request

Perplexity is a good fit when your app depends on recent, source-backed information such as news, research, market intelligence, or fact verification.

## Common use cases and example apps

These examples show what you can build with Perplexity, each with a prompt to start from.

| Example app                        | Example prompt                                                                                                         | Description                                                                                                                                                                                    |
| :--------------------------------- | :--------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Sales prep assistant**           | *Use Perplexity and build a sales prep assistant that gathers company context before each call.*                       | **Pull company overviews, recent news, and leadership changes with live search.**<br />The app runs Perplexity queries before a meeting and presents a concise, cited briefing for sales reps. |
| **Competitor research tool**       | *Use Perplexity and build a competitor research tool that summarizes funding, launches, and positioning changes.*      | **Summarize market activity across many sources at once.**<br />The app runs several Perplexity searches in parallel and aggregates the cited results into a research dashboard.               |
| **Regulatory tracker**             | *Use Perplexity and build an app that tracks regulatory updates and policy changes for our industry.*                  | **Monitor new rulings and compliance updates from recent sources.**<br />The app queries Perplexity on a schedule and surfaces newly published or updated information with citations.          |
| **Fact-checking app**              | *Use Perplexity and build a fact-checking app that verifies a statement against supporting and contradicting sources.* | **Check claims against live sources.**<br />The app accepts a statement as input and returns a synthesized verdict with cited references.                                                      |
| **Academic research assistant**    | *Use Perplexity and build a research assistant that answers questions from peer-reviewed papers only.*                 | **Answer open-ended questions from scholarly sources.**<br />The app uses Perplexity's academic search mode to generate structured, cited responses.                                           |
| **Deep research report generator** | *Use Perplexity and build a tool that produces a long-form research report on a topic with sources.*                   | **Turn one question into a full report.**<br />The app calls Perplexity's deep research model, which runs many queries and synthesizes a report in a single request.                           |

## How to connect Perplexity

Who can create Perplexity connections depends on your plan and workspace settings. App + chat connectors are available by default on Free, Pro, and Business plans. On Enterprise plans, they are effectively disabled at first: [Who can create connections and clients](/integrations/admin-controls#who-can-create-connections-and-clients) defaults to **No one** until an admin changes it in **Connectors → Admin settings → App + chat connectors**.

You can create multiple Perplexity connections using different API keys, which is useful for separating environments (for example, development and production) or managing spend per environment.

When the connection is created, you can [link it to the projects](/integrations/app-connectors#link-a-connection-to-a-project) where you want to use it. Anyone building in a project can ask Lovable in chat to link their project to it.

### Prerequisites

Before connecting Perplexity, make sure you have:

* A Perplexity account with permission to manage billing and API keys, and a payment method or API credits set up
* A Perplexity API key
* Permission to **create connections** in your Lovable workspace (see [Who can create connections and clients](/integrations/admin-controls#who-can-create-connections-and-clients))

<Note>
  All search and answer requests through this connector consume Perplexity API credits. API credits are managed separately from a Perplexity Pro subscription. Billing is handled directly by Perplexity, not Lovable.
</Note>

### Step 1: Get a Perplexity API key

A Perplexity API key lets your Lovable app authenticate with the Perplexity API. You can create multiple keys in Perplexity.

To create a Perplexity API key:

<Steps>
  <Step title="Open the Perplexity API console">
    Sign in to the [Perplexity API console](https://console.perplexity.ai/) with your Perplexity account.
  </Step>

  <Step title="Set up your API group and billing">
    If this is your first key, open **Settings** and enter your organization details (name, address, and tax details). Then open **Billing** and click **Add payment method**, or add API credits. Keys without credits return quota errors.
  </Step>

  <Step title="Create a key">
    Open **API keys** and click **Generate API Key**. Give the key a descriptive name, for example `Lovable integration`.
  </Step>

  <Step title="Copy the key">
    Copy the generated API key and store it securely. It starts with `pplx-`.
  </Step>
</Steps>

<Warning>
  Your API key functions like a password. Keep it secure and never share it publicly. You'll need it in the next step.
</Warning>

See Perplexity documentation for more: [API groups and billing](https://docs.perplexity.ai/getting-started/api-groups).

### Step 2: Connect Perplexity to Lovable

You can create multiple connections using different API keys.

<Steps>
  <Step title="Open Perplexity in Connectors">
    Open [**Connectors**](https://lovable.dev/dashboard?connectors) and select **Perplexity**. For the other places to open the catalog from, see [Where to find connectors](/integrations/introduction#where-to-find-connectors).
  </Step>

  <Step title="Add a connection">
    Click **Add connection**.
  </Step>

  <Step title="Configure the connection">
    1. **Display name**: name the connection, for example `Perplexity Prod`. This name is only used inside Lovable to identify the connection.
    2. **API key**: paste your Perplexity API key (it starts with `pplx-`). **Get value** next to the field opens the Perplexity API console.
  </Step>

  <Step title="Choose who can use this connection">
    Under **Who can use this connection**, decide who in your workspace can use the connection. You start as the only person with access:

    * **Only you** (default): leave the access list as is; only you can use the connection and its associated data.
    * **Invite specific people**: add workspace members by email; only you and the people you add can use the connection and its associated data.
    * **Invite entire workspace**: click **Invite entire workspace** to make the connection available to everyone in your Lovable workspace.

    See [Who can use connections and clients](/integrations/admin-controls#who-can-use-connections-and-clients) for more information.
  </Step>

  <Step title="Connect">
    Click **Connect**. Lovable verifies the key against the Perplexity API before saving the connection.
  </Step>
</Steps>

When connected, anyone building in a project can ask Lovable in chat to link their project to Perplexity (based on configured connection-level access). Your Lovable apps can then retrieve cited, up-to-date answers from Perplexity.

<Note>
  Unlike most app + chat connectors, Perplexity does not route through Lovable's [connector gateway](/integrations/app-connectors#gateway-based-connectors). Lovable stores the API key as a secret in each linked project, and your app calls Perplexity from its server, never from the browser.
</Note>

## Limitations

The Perplexity connector cannot:

* Rotate API keys automatically. To rotate, create a new key in Perplexity and update the Lovable connection.
* Support per-end-user Perplexity login. Each connection represents a single Perplexity account shared across all projects linked to it.

## Troubleshooting

If requests through the connection fail, the section below covers the most common error and how to resolve it.

<AccordionGroup>
  <Accordion title="Requests fail with 401 and &#x22;insufficient_quota&#x22;">
    The API key is valid, but the Perplexity account it belongs to has run out of API credits. Buy or top up API credits in the [Perplexity API console](https://console.perplexity.ai/) for that account. A Pro subscription's credits are managed separately.
  </Accordion>
</AccordionGroup>

## Manage your {connector_0} connection

Connections are managed from [**Connectors**](https://lovable.dev/dashboard?connectors): select **{connector_0}**, then open the connection.

* **Unlink projects** to remove {connector_0} access from specific projects while keeping the connection available for others. See [Unlink projects from a connection](/integrations/app-connectors#unlink-projects-from-a-connection) for the steps.
* **Delete the connection** to remove it from the workspace entirely. Deleting is permanent. It removes the credentials from all linked projects, and app features that use {connector_0} stop working until a new connection is added. See [Delete a connection](/integrations/app-connectors#delete-a-connection) for the steps and who can delete.


## Related topics

- [Connect your app to Workday](/integrations/workday.md)
- [Connect your app to Notion](/integrations/notion.md)
- [Connect your app to Granola](/integrations/granola.md)
- [Connect your app to Slack](/integrations/slack.md)
- [Connect your app to Inngest](/integrations/inngest.md)