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

# Access and billing

> Who can use CodeRabbit's Coding Agent, which turns are free, how metered agent minutes work, and what the monthly spend cap does when it's reached.

export const OpenBetaBadge = ({tip = "This feature is currently in open beta. We are actively improving it based on your feedback. If you encounter any issues or have suggestions, please share them on our Discord community or visit the support page.", title = "Open Beta", cta = "Contact support", href = "/support", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="badge-alert" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const AdminRoleBadge = ({tip = "This feature requires an organization owner, an admin role or the corresponding permission. Regular Members do not have access.", title = "Admin Only", cta = "View roles", href = "/management/roles", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="lock" color="orange" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const BitbucketBadge = ({tip = "This feature is available on Bitbucket.", title = "Bitbucket", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="bitbucket" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const AzureBadge = ({tip = "This feature is available on Azure DevOps.", title = "Azure", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="microsoft" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const GitLabBadge = ({tip = "This feature is available on GitLab.", title = "GitLab", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="gitlab" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const GitHubBadge = ({tip = "This feature is available on GitHub and GitHub Enterprise.", title = "GitHub", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="github" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

<GitHubBadge /> <GitLabBadge /> <AzureBadge title="Azure DevOps" /> <BitbucketBadge title="Bitbucket Cloud" /> | <OpenBetaBadge tip="Coding Agent is in beta." />

## Overview

Two separate things decide whether a coding task can run: whether the starting point is **available** to your organization, and whether the turn can be **paid for**. They fail differently and are fixed differently, so it's worth keeping them apart.

## Access

Coding Agent is in beta and is not one switch. Access is granted to your organization first, and then separately for each way of starting a task — the app, chat, each finishing touch, pull request fixes, security fixes, approved plans, and the Change Stack panel. The starting point availability may depend on your platform and plan.

The practical consequences:

* Seeing one starting point does not mean the others are enabled. An organization can have Autofix on a pull request while the standalone app is not yet available to it.
* Access fails closed. A starting point your organization hasn't been granted isn't offered, rather than failing when you use it.
* If a starting point documented here is missing for your organization, [contact support](/support).

For which providers each starting point supports, see [Where each starting point is available](/code/start-a-task#where-each-starting-point-is-available).

## Provider authorization

Coding Agent delivers changes with **your own** Git provider authorization, not with a shared service account. You need a valid, current authorization for the provider account you're delivering as. If it has expired or been revoked, delivery is refused until you reauthorize.

This is what keeps branch protections, repository permissions, and your provider's audit trail meaningful. See [Who pushes, and who wrote it](/code/deliver-changes#who-pushes-and-who-wrote-it).

## Who can see a task

Tasks are visible to your organization by default, so a teammate can pick up where you left off.

A task's author can make it **private**, which restricts its prompts, files, activity, and attachments to the author alone — including for anyone who follows a direct link. The author can switch it back at any time. See [Control who can see a task](/code/work-with-a-task#control-who-can-see-a-task).

## Free turns

A **turn** is one run of the agent against one instruction. Starting a task is a turn; every message you send it afterwards — a steer, a queued follow-up, a revision request — starts another.

Some first turns are free, because they come from an action CodeRabbit offered you rather than one you asked for:

| Starting point                                                       | Free turn                         |
| -------------------------------------------------------------------- | --------------------------------- |
| [Autofix](/finishing-touches/autofix)                                | The initial fix turn.             |
| [Finishing Touches](/finishing-touches/index)                        | The initial finishing-touch turn. |
| [Resolve merge conflicts](/finishing-touches/resolve-merge-conflict) | The initial handoff turn.         |
| CodeRabbit Security **Fix with AI**                                  | The initial security-fix turn.    |

The free turn is the *first* one on those tasks. Steering the task, asking for a revision, or queueing a follow-up all start further turns, and those are billed normally.

## Agent minutes

<AdminRoleBadge tip="Activating the add-on and setting the cap are administrator actions." />

Beyond the free turns above, a turn needs one of:

* available **trial credits**,
* an organization configured for **unlimited** turns, or
* an active **agent minutes** add-on, which meters usage.

An administrator activates the agent minutes add-on in the organization's billing settings. Until it is active, paid turns are refused with a message saying metered billing is not enabled for the organization.

<Info>
  Agent minutes are a metered add-on rather than a plan tier. For what each CodeRabbit plan includes, see [Plans](/management/plans).
</Info>

## Monthly spend cap

An administrator can set a monthly cap on metered agent minutes. Once accumulated spend for the month reaches the cap, new paid turns are refused.

The cap stops future spending and nothing else: existing tasks, their history, and any work already delivered are untouched. Raise or remove the cap in billing settings to start paid turns again.

Two of these are ordinary eligibility outcomes, and the message tells you which:

| Reason                        | What it means                                               | What to do                                  |
| ----------------------------- | ----------------------------------------------------------- | ------------------------------------------- |
| Metered billing is not active | The organization has no active agent minutes add-on.        | An administrator activates the add-on.      |
| Monthly cap reached           | Accumulated spend for the month has hit the configured cap. | An administrator raises or removes the cap. |

A turn can also be blocked when CodeRabbit can't verify the organization's billing at all — an ambiguous or unavailable subscription, rather than a decision about your entitlement. That is a temporary condition, not something to configure; if it persists, [contact support](/support).

## Consumed minutes

Organizations can see the coding minutes already consumed, shown alongside the billing notice and in the task experience. This display is rolled out separately from the rest of Coding Agent, so it may not be visible even where tasks are working normally.

## What's next

<CardGroup cols={1}>
  <Card title="Start a coding task" href="/code/start-a-task" icon="play" horizontal>
    Every way to start a task and where each one is available.
  </Card>

  <Card title="Deliver a task's changes" href="/code/deliver-changes" icon="git-pull-request" horizontal>
    Choose how accepted changes land, and what to do when delivery is blocked.
  </Card>

  <Card title="Plans" href="/management/plans" icon="receipt" horizontal>
    Compare what each CodeRabbit plan includes.
  </Card>
</CardGroup>