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

# Connections

> Connect external tools and APIs to your workspace so CodeRabbit Agent for Slack can access issue trackers, documentation, observability, and custom integrations.

export const Hint = ({type, children, headline, tip, href, cta}) => {
  const TIPS = {
    learnings: {
      headline: "Learnings",
      tip: "Review preferences CodeRabbit learns from your chat conversations and applies automatically to future reviews.",
      cta: "Learn about Learnings",
      href: "/knowledge-base/learnings",
      content: "Learnings"
    },
    walkthrough: {
      headline: "PR Walkthrough",
      tip: "A structured comment posted by CodeRabbit at the top of every pull request, summarizing changes, sequence diagrams, review effort, and more.",
      cta: "Learn about PR Walkthroughs",
      href: "/pr-reviews/walkthroughs",
      content: "Walkthrough"
    },
    "finishing-touches": {
      headline: "Finishing Touches",
      tip: "Post-review agentic actions (Autofix, writing docstrings or unit tests, and more) you trigger from a PR comment or a checkbox in the Walkthrough.",
      cta: "See all Finishing Touches",
      href: "/finishing-touches",
      content: "Finishing Touches"
    },
    "coding-plan": {
      headline: "Coding Plan",
      tip: "A detailed, codebase-aware implementation plan CodeRabbit generates from an issue or description, ready to hand off to any coding agent.",
      cta: "Learn about Coding Plans",
      href: "/plan",
      content: "Coding Plan"
    },
    "knowledge-base": {
      headline: "Knowledge Base",
      tip: "The collected context sources CodeRabbit draws on during reviews: Learnings, Code Guidelines, issue trackers, connected MCP servers, and cross-repo analysis.",
      cta: "Explore the Knowledge Base",
      href: "/knowledge-base",
      content: "Knowledge Base"
    },
    "path-instructions": {
      headline: "Path Instructions",
      tip: "Custom review rules that only apply to files matching a glob pattern, e.g. 'src/controllers/**'.",
      cta: "Configure path instructions",
      href: "/configuration/path-instructions",
      content: "Path Instructions"
    },
    scope: {
      headline: "Scope",
      tip: "A named set of repositories, connections, and spend limits that controls what CodeRabbit Agent can access in a given Slack conversation.",
      cta: "Learn about Scopes",
      href: "/slack-agent/scopes",
      content: "Scope"
    }
  };
  const defaults = TIPS[type] || ({});
  return <Tooltip headline={headline ?? defaults.headline} tip={tip ?? defaults.tip} cta={cta ?? defaults.cta} href={href ?? defaults.href}>
      {children ?? defaults.content}
    </Tooltip>;
};

Connections give CodeRabbit Agent for Slack access to external tools like issue trackers, documentation, observability dashboards, MCP servers and custom APIs. You configure them once at the workspace level and assign them to the <Hint type="scope">scopes</Hint> that need them.

All signed-in users can open the Connections page. Creating, editing, reconnecting, or deleting a connection requires either global admin access or assigned scope-admin access.

## How connections are organized

Each service type (Jira, Linear, Notion, Sentry, Google Drive, etc.) is a **connector**. A **connection** is a specific account or credential under that connector. You can create multiple connections for the same connector if different teams need separate accounts or permissions.

## Supported connection categories

CodeRabbit Agent groups connections by category in the connection catalog:

| Category            | Services                                |
| ------------------- | --------------------------------------- |
| Docs & Knowledge    | Notion, Google Drive, OneDrive          |
| Issue tracking      | Jira, Linear, Asana                     |
| Observability       | Datadog, Sentry                         |
| Incident Management | PagerDuty                               |
| CI/CD               | CircleCI                                |
| Product Analytics   | PostHog, Google Analytics, Google Ads   |
| CRM                 | HubSpot, Salesforce                     |
| Support             | Zendesk, Fin (formerly Intercom), Pylon |
| Sales Intelligence  | Gong                                    |
| Design              | Figma, Canva                            |
| Infrastructure      | AWS, GCP                                |
| Custom              | MCP servers and APIs                    |

The exact catalog is product-defined and evolving. The important model is that connections are created once at the workspace level and then selected where needed.

## Add a connection

<Steps>
  <Step title="Open Connections in the web app">
    Go to **Connections** in the CodeRabbit Agent dashboard and click **Add connection**. To add or edit a connection, you need either global admin access (Slack admin, workspace owner, or `cr_admin` holder) or assigned scope-admin access.
  </Step>

  <Step title="Pick a connector">
    A searchable grid shows all available connector types (Jira, Linear, Notion, Sentry, Google Drive, Google Ads, and more). Select the service you want to connect. If your tool is not listed, choose **Custom** to connect it through an MCP server, API endpoint, or other custom integration.
  </Step>

  <Step title="Name and describe the connection">
    Give the connection a **name** (required, at least 2 characters) and an optional **description**. The name defaults to something like "Jira OAuth RO" but you can change it to anything that helps your team identify this connection.
  </Step>

  <Step title="Authenticate">
    The form shows one or more authentication tabs depending on what the connector supports:

    <Tabs>
      <Tab title="OAuth">
        1. Fill in any required fields (such as a site URL for Jira, customer IDs for Google Ads, or a base URL for Sentry)
        2. **Save** the connection first
        3. Click **Connect \[Service]** to open the provider's authorization page in a new tab
        4. Authorize CodeRabbit in the provider
        5. You are redirected back, and the form shows a "Connected" status with the account email and granted scopes
      </Tab>

      <Tab title="API key / Credentials">
        Paste a token, API key, or structured credentials depending on the service:

        * **Most services**: A single API key or token field
        * **Jira**: Atlassian account email + API token
        * **Gong**: Access key + access key secret
        * **Datadog**: API key + a site selector (e.g., datadoghq.com vs datadoghq.eu)

        Credential values are masked by default and stored securely.
      </Tab>

      <Tab title="MCP server">
        For custom tool integrations using the Model Context Protocol:

        1. Enter a **server name** and **server URL** (HTTP, HTTPS, or WebSocket)
        2. Choose a **transport type**: SSE, Streamable HTTP, or WebSocket
        3. Add an **auth header name** and **auth header value** if the server requires authentication

        See [MCP servers](/integrations/mcp-servers) for more on setting up MCP integrations.
      </Tab>
    </Tabs>
  </Step>

  <Step title="Test the connection">
    Click **Test** to validate that the credentials work. This is available for most connectors after saving. If the test fails, check your credentials or URL fields and try again.
  </Step>

  <Step title="Save">
    Click **Save** to create the connection at the workspace level. The connection is now available but not yet assigned to any scope.
  </Step>

  <Step title="Assign to a scope">
    Go to [Scopes](/slack-agent/scopes) and add the new connection to the Base Scope or a scope. The connection does nothing until at least one scope includes it.
  </Step>
</Steps>

## Connector-specific notes

Some connectors require additional fields during setup:

| Connector    | Extra configuration                                                              |
| ------------ | -------------------------------------------------------------------------------- |
| Jira         | Site URL (required for both OAuth and credential modes)                          |
| Sentry       | Base URL (sentry.io or a regional variant)                                       |
| PagerDuty    | Base URL (api.pagerduty.com or regional)                                         |
| Datadog      | Site selector (datadoghq.com, datadoghq.eu, etc.)                                |
| Google Ads   | Customer ID (required) and optional Login Customer ID for manager-account access |
| Google Drive | Service account JSON upload when using service account mode                      |
| Linear       | Policy mode choice: read-only or read-write (OAuth only)                         |
| AWS          | Account ID (12 digits) + region                                                  |

## How connections work with scopes

Creating a connection does not grant CodeRabbit Agent access on its own. A connection only becomes available when a [scope](/slack-agent/scopes) explicitly includes it. This means you can configure connections at the workspace level and then decide, scope by scope, which teams or channels should be able to use each one.

For most service types, a scope can include one connection per service. MCP connections are the exception: they are additive, so a scope's MCP servers stack on top of those already included in the Base Scope.

The Connections list shows a **Scopes** column so admins can see where each connection is currently assigned. Linked scopes appear by name, and unassigned connections show **No scopes**. Search also matches linked scope names, which helps you find all connections used by a specific team, channel, or workflow.

## Who can do what

| Action                          | Global admin | Scope admin | Member |
| ------------------------------- | ------------ | ----------- | ------ |
| View configured connections     | Yes          | Yes         | Yes    |
| Create or edit connections      | Yes          | Yes         | No     |
| Reconnect or rotate credentials | Yes          | Yes         | No     |
| Delete connections              | Yes          | Yes         | No     |

## Reusing existing integrations and creating new ones

If your team already uses CodeRabbit for pull request reviews, you may already have integrations configured for services like Jira or Linear. CodeRabbit Agent can reuse those existing integrations as connections, so you do not need to set them up again from scratch.

Create a separate connection when the existing one does not fit: for example, when a different team needs its own account for the same service, when you want a stricter permission mode (read-only instead of read-write), or when a specific scope should only see a subset of a service's data.

## What's next

<CardGroup cols={1}>
  <Card title="Scopes" href="/slack-agent/scopes" icon="shield" horizontal>
    Decide which scopes should be allowed to use each connection.
  </Card>

  <Card title="Knowledge Base" href="/slack-agent/knowledge-base" icon="brain" horizontal>
    Learn how CodeRabbit Agent uses connected systems to build and refine durable workspace knowledge.
  </Card>

  <Card title="MCP servers" href="/integrations/mcp-servers" icon="server" horizontal>
    See the canonical docs for MCP-based integrations that CodeRabbit Agent can use through workspace connections.
  </Card>
</CardGroup>