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

> Connect your app to Attention, a sales conversation intelligence platform, to read meeting transcripts and scorecards, write back snippets and QA results, and ask natural-language questions across your sales conversations.

export const connector_0 = "Attention"

[Attention](https://www.attention.com/) is a sales conversation intelligence and coaching platform that records, transcribes, and analyzes customer-facing meetings. The Attention connector lets your Lovable app read conversations, transcripts, and scorecards from Attention, and write back snippets, scorecard results, and conversation updates, so you can build dashboards, briefings, coaching tools, and QA workflows on top of your sales motion.

With Attention, your app can:

* List and retrieve sales conversations and meeting metadata
* Read full meeting transcripts, participants, and timing details
* Surface scorecards, insights, and coaching signals from the Attention API
* Update, archive, or import conversations, and create snippets and scorecard results
* Ask natural-language questions across your conversation history with Attention's semantic AI endpoint
* Pull and manage organization, team, and user data
* Combine conversation data with the rest of your app's content (CRM views, internal tools, AI summaries)

The Attention connector is a good fit when your sales team already runs on Attention and you want to give the rest of the company a tailored window into the conversations happening there.

## Common use cases and example apps

| Example app                               | Example prompt                                                                                                                             | Description                                                                                                                                                                                                                      |
| :---------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Deal-room conversation viewer**         | *Use Attention and build a deal-room view that lists recent conversations for an account, with transcripts, participants, and durations.*  | **Bring meeting context next to the deal.**<br />The app fetches conversations from Attention, filters by account or owner, and renders transcripts and participant lists alongside whatever deal info your team already tracks. |
| **Weekly sales briefing app**             | *Use Attention and build a weekly briefing that summarizes last week's customer calls and emails it to the team.*                          | **Turn raw conversations into a leadership-ready digest.**<br />The app pulls the last seven days of conversations, summarizes themes and risks, and produces a recurring digest the team can scan in minutes.                   |
| **Coaching and scorecard dashboard**      | *Use Attention and build a coaching dashboard that shows scorecard results and trends per rep.*                                            | **Make coaching signals legible across the team.**<br />The app reads scorecards and conversation metadata from Attention and presents trends per rep, so managers can spot what to coach on next.                               |
| **Ask-your-calls chatbot**                | *Use Attention and build a chatbot that answers questions about our sales calls, like "what objections came up about pricing last month?"* | **Query meetings in plain English**<br />The app uses Attention's Ask Attention endpoint to run semantic queries across conversations and returns grounded answers with source calls.                                            |
| **Auto-tagging and QA tool**              | *Use Attention and build a tool that submits scorecard results and updates conversations after an external QA review.*                     | **Push structured QA back into Attention.**<br />The app reads conversations, lets reviewers score them in a custom UI, then writes scorecard results and updates conversation metadata back via the Attention API.              |
| **Onboarding library for new reps**       | *Use Attention and build an onboarding library of best-of calls grouped by deal stage.*                                                    | **Curate calls into a learning experience.**<br />The app pulls selected conversations from Attention and organizes them by stage or topic so new reps can ramp by listening to real customer calls.                             |
| **Risk and pipeline review app**          | *Use Attention and build a pipeline review that flags deals where recent calls mention risk language.*                                     | **Surface risk signals from conversations.**<br />The app combines conversation transcripts and scorecards to highlight deals that need attention before the next forecast call.                                                 |
| **Internal "voice of the customer" feed** | *Use Attention and build an internal feed of customer quotes pulled from recent meetings.*                                                 | **Distribute the voice of the customer across the company.**<br />The app surfaces highlights from Attention conversations as a feed product, support, and design teams can browse.                                              |

## How to connect Attention

Workspace **admins** and **owners** can connect Attention.

You can create multiple Attention connections using different API keys. This is useful for separating environments (for example, development and production), isolating access for specific apps, or managing usage limits independently.

When the connection is created, Attention can be linked to any project in the workspace. Multiple projects can use the same connection.

### Prerequisites

Before connecting Attention, make sure you have:

* An Attention account with admin role permissions in your organization
* An Attention API key
* Lovable workspace owner or admin role

<Note>
  All API requests made through this connector use your Attention API key. Usage counts toward your Attention plan limits and billing is handled directly by Attention, not Lovable.
</Note>

### Step 1: Create an Attention API key

An **Attention API key** is an organization-level Bearer token that lets your Lovable app authenticate against Attention's v2 API. You must have **Admin** role permissions in Attention to create and manage organization-level API keys.

To create an Attention API key:

<Steps>
  <Step title="Log in to Attention">
    Go to [app.attention.tech](https://app.attention.tech) and sign in with Google, SSO, or your email and password.
  </Step>

  <Step title="Open settings">
    Click your profile avatar in the top-left corner and select **Settings** from the dropdown menu.
  </Step>

  <Step title="Navigate to API keys">
    In the sidebar, under the **Organization** section, select **API Keys**.
  </Step>

  <Step title="Create a new API key">
    Click **+ Create API Key** in the top-right corner and give the key a descriptive name, for example `Lovable integration`.
  </Step>

  <Step title="Copy and store the key">
    After creation, an **API Key Created** modal will appear showing your key once. Copy the key and store it securely. Attention will not show it again.
  </Step>
</Steps>

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

See Attention's docs for detailed instructions: [API authentication](https://docs.attention.com/api-authentication).

### Step 2: Connect Attention to Lovable

You can create multiple connections using different API keys.

To connect Attention:

<Steps>
  <Step title="Open Attention in Connectors">
    Go to **Connectors → App connectors** and select **Attention**.
  </Step>

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

  <Step title="Configure the connection">
    1. **Display name**: Name the connection, for example `Attention Prod`.
    2. **API key**: Paste your Attention API key.
    3. **Who can access this connection**: Keep access limited to specific people or invite the entire workspace. See [Connection-level access](/integrations/introduction#connection-level-access) for more information.
  </Step>

  <Step title="Connect">
    Click **Connect**. Lovable validates the key against Attention before saving the connection. If the key is invalid or has been revoked, the connection will fail and you can paste a new one.
  </Step>
</Steps>

When connected, your Lovable apps can start reading from and writing to conversations, transcripts, and related data from Attention.

<Warning>
  Attention API keys inherit the permissions of the Admin who creates them, there is no per-key scope picker.

  Any Lovable app linked to a connection can read **and write** any data the key has access to in Attention, including updating or archiving conversations, creating or deleting users, and managing teams. Only link the connection to projects that should have that level of access.
</Warning>

## Working with conversation data

The Attention API returns rich conversation objects that include metadata, participants, and full transcripts, and supports updating, archiving, and importing conversations. When prompting Lovable, be specific about what you want.

Conversations include sensitive customer information. Plan how the data is displayed in your app and who can see it before sharing the app broadly inside your company.

## Limitations

The Attention connector cannot:

* Receive Attention webhooks or real-time conversation events (poll the API on a schedule instead)
* Support per-end-user Attention login (each end user connecting their own Attention account). All requests use the workspace API key, so every end user of your Lovable app sees the same Attention data.

Attention enforces rate limits on its API. If you build apps that paginate through many conversations or run frequent background jobs, expect occasional `429 Too Many Requests` responses and add retry-with-backoff in your edge functions.

If a request fails because the API key has been revoked or rotated in Attention, you'll need to generate a new key and reconnect. There is no automatic refresh for API keys.

## How to unlink projects from a {connector_0} connection

Editors and above can remove specific projects from a connection without deleting the connection entirely. The connection will remain available for other projects.

To unlink projects:

<Steps>
  <Step title="Open Connectors">
    Open **Connectors**, then go to **App connectors**, and select **{connector_0}**.
  </Step>

  <Step title="Open the connection">
    Open the connection you want to manage.
  </Step>

  <Step title="Select projects">
    Under **Linked projects**, check the projects you want to unlink.
  </Step>

  <Step title="Confirm">
    Click **Unlink projects** and confirm.
  </Step>
</Steps>

When unlinked, those projects will no longer have access to {connector_0} through this connection. If a project needs {connector_0} again, you can link it to any available connection.

## How to delete a {connector_0} connection

Workspace admins and owners can delete {connector_0} connections.

<Warning>
  Deleting a connection is permanent and cannot be undone. It will remove the credentials from all linked projects, and any apps using this connection will stop working until a new connection is added.
</Warning>

Before deleting, review the **Linked projects** section to see which projects are currently using the connection.

To delete a connection:

<Steps>
  <Step title="Open Connectors">
    Open **Connectors**, then go to **App connectors**, and select **{connector_0}**.
  </Step>

  <Step title="Open the connection">
    Open the connection you want to remove.
  </Step>

  <Step title="Review linked projects">
    Review the **Linked projects** section.
  </Step>

  <Step title="Delete">
    Under **Delete this connection**, click **Delete** and confirm.
  </Step>
</Steps>