# Billing
Source: https://docs.cursor.com/account/billing
Guide to Cursor billing: manage subscriptions, seats, cycles, and payments through Stripe portal
We use Stripe as our billing and payments provider
### How do I access billing settings?
The billing portal is where you'll manage all aspects of your subscription. You can access it through the [dashboard](https://cursor.com/settings) by clicking the "Billing" button in your account settings. This takes you to a secure portal where you can handle all billing-related tasks.
### What are Cursor's billing cycles?
Billing cycles run on either a monthly or annual basis, starting on the day you subscribe. For Business accounts with multiple seats, we use prorated billing when your team size changes. This means you only pay for the actual time each seat is used within a billing cycle.
### How do team seats work for Business accounts?
Business accounts use a per-seat billing model where each team member requires one seat license. When adding new members mid-cycle, you're only charged for their remaining time in that billing period. Team admins can manage seats directly through the dashboard.
### Can I switch between monthly and annual billing?
Yes you can! Here's how:
**Pro plan**
1. Go to [settings](https://cursor.com/settings)
2. Click on "Manage subscription" and you will be taken to the billing portal
3. Click on "Update subscription"
4. From here you can switch between monthly and annual billing
5. Select "Yearly" or "Monthly", then click on "Continue"
**Business plan**
1. Go to [settings](https://cursor.com/settings)
2. In the account section, click on "Advanced" then "Upgrade to yearly billing"
Please note that you can only switch from monthly to yearly billing
self-serve. To switch from yearly to monthly billing, please contact us at
[hi@cursor.com](mailto:hi@cursor.com).
### Where can I find my invoices?
All your billing history is available in the billing portal, where you can view and download both current and past invoices.
### Can I get invoices automatically emailed to me?
Currently, invoices need to be downloaded manually from the billing portal. We know this is a hassle, so we're developing automatic invoice emails as a new feature, and once available, you'll be able to opt-in!
### How do I update my billing information?
You can update your payment method, company name, address, and tax information through the billing portal. We use Stripe as our payment processor to ensure secure transactions. Please note that changes to billing information will only affect future invoices - we cannot modify historical invoices.
### How do I cancel my subscription?
You can cancel your subscription directly through the billing portal using the "Cancel subscription" button. Your access will continue until the end of your current billing period.
### I'm having other billing issues. How can I get help?
For any billing-related questions not covered here, please email us at [hi@cursor.com](mailto:hi@cursor.com). Include your account details and specific concerns, and our team will help you resolve them quickly!
### Can I get a refund?
You can self-serve a refund by going to the billing portal and clicking on the `Cancel subscription` button. Our self-serve refund policy is as follows:
**EU, UK or Turkey customers**
* Eligible for a refund if you cancel your subscription within 14 days of purchase.
**All other customers (US + rest of world)**
* Monthly subscriptions: Refundable within 24 hours after purchase.
* Annual subscriptions: Refundable within 72 hours after purchase
If you're not in the window of self-serve refunds, reach out to us at [hi@cursor.com](mailto:hi@cursor.com) and we'll help you!
# Dashboard
Source: https://docs.cursor.com/account/dashboard
Learn how to manage billing, usage pricing, and team settings in the dashboard for different plans
From the dashboard you can access billing portal, setup usage based pricing and manage your team. Depending on if you're on Free, Pro or Business, you'll see different sections.
## Pro
From here you can access billing portal, setup usage based pricing and see how many requests you have left.
## Business
Business will have a section for teams.
### Team
Read more about how to manage teams in [members](/account/teams/members)
### Metrics
Read more in [team analytics](/account/teams/analytics). This is only available for teams
### Usage based pricing
This is where you can toggle usage based pricing and set spending limits. Read more about [usage based pricing](/account/usage) and how to configure it
# Plans
Source: https://docs.cursor.com/account/plans
Compare Cursor pricing plans: Hobby, Pro & Business tiers with feature breakdowns and trial info
- 50 slow `premium` model uses per month
- 2000 [completions](/tab/overview)
- 500 fast `premium` model requests per month
- Unlimited slow `premium` model requests per month
- Unlimited [completions](/tab/overview)
- 10 o1-mini per month
- Same usage as Pro
- Enforces privacy mode
- Centralized team billing
- Admin dashboard with usage stats
- SAML/OIDC SSO
For costs and more pricing info, please visit the [Cursor
Pricing](https://cursor.com/pricing) page.
## Pro trial
Every new users gets a free Pro trial when they sign up. When the Pro trial last for 14 days or until reaching the usage quotas detailed on our [pricing page](https://www.cursor.com/pricing). After trial expiration, you'll need to upgrade to continue using Pro features. You can upgrade at any time during your trial.
# Pricing
Source: https://docs.cursor.com/account/pricing
# Privacy
Source: https://docs.cursor.com/account/privacy
A guide to Cursor's privacy settings, data handling, and code indexing with Privacy Mode option
For a comphrehensive privacy overview, read our [privacy page](https://www.cursor.com/privacy)
## FAQ
### What is Privacy Mode?
With `Privacy Mode` enabled, none of your code will ever be stored by us or any third-party. Otherwise, we may collect prompts, code snippets and telemetry data to improve Cursor. You can [read more about Privacy Mode here](https://cursor.com/privacy). Privacy mode is enforced for Business plans
You can enable `Privacy Mode` at onboarding or under `Cursor Settings` > `General` > `Privacy Mode`.
### Are requests always routed through the Cursor backend?
Yes! Even if you use your API key, your requests will still go through our backend. That's where we do our final prompt building.
### Does indexing the codebase require storing code?
It does not! If you choose to index your codebase, Cursor will upload your codebase in small chunks to our server to compute embeddings, but all plaintext code ceases to exist after the life of the request.
The embeddings and metadata about your codebase (hashes, obfuscated file names) are stored in our database, but none of your code is.
You can read more about this on our [security page](https://cursor.com/security).
# Security
Source: https://docs.cursor.com/account/security
# Analytics
Source: https://docs.cursor.com/account/teams/analytics
Track team metrics including usage stats, per-user activity, and active user counts from the dashboard
Team admins can track metrics for their team from the [dashboard](/account/dashboard).
Expect this to improve a lot during H1 2025, including API for programmatic
access
The metrics dashboard shows usage statistics for your team over the last 30 days:
### Total Usage
View aggregate metrics across your entire team, including total tabs and premium requests used. For teams less than 30 days old, metrics reflect actual usage since team creation, including activity from team members' individual accounts prior to joining.
### Per Active User
See average usage metrics per active user, including tabs accepted, lines of code, and premium requests.
### User Activity
Track both weekly and monthly active user counts.
## FAQ
The difference in numbers you're seeing is because the team tab shows requests for the current billing period, while the metrics page shows a rolling 30-day window. We know is can be confusing - we're working on making this clearer in the dashboard.
# Members
Source: https://docs.cursor.com/account/teams/members
Learn about team roles, member management, SSO, usage controls, and billing for organizational teams
import { Accordion, AccordionGroup } from "@/components/Accordion";
## Roles
Teams have access to three user roles to help manage teams. Each role has specific permissions and billing implications.
* Access to all [Business features](https://cursor.com/pricing)
* Can invite team members
* Billed for a user seat
Admins have comprehensive control over team management and security settings to ensure smooth team operations.
* Full team management capabilities:
* Invite/remove team members
* Modify team roles
* Usage and security controls:
* Toggle usage-based pricing
* Configure SSO & domain verification
* Set organization-wide spending caps
* Access to admin dashboard
* Billed for a user seat
Unpaid Admins manage the team without using a paid seat - ideal for IT staff who don't need Cursor access.
* Same capabilities as Admin
* **Not billed for a user seat**
* Requires at least one paid Admin on the team to assign this role
### Comparison
| Capability | Member | Admin | Unpaid Admin |
| ---------------------- | :----: | :---: | :----------: |
| Use Cursor features | ✓ | ✓ | |
| Invite members | ✓ | ✓ | ✓ |
| Remove members | | ✓ | ✓ |
| Change user role | | ✓ | ✓ |
| Admin dashboard | | ✓ | ✓ |
| Configure SSO/Security | | ✓ | ✓ |
| Manage Billing | | ✓ | ✓ |
| Set usage controls | ✓ | ✓ | ✓ |
| Requires paid seat | ✓ | ✓ | |
## Managing members
All members in the team can invite other members. We currently do not have any way to control invites.
### Add member
#### Email invitation
* Click the `Invite Members` button
* Enter email addresses
#### Invite link
* Click the `Invite Members` button
* Copy the `Invite Link`
* Share with team members
Invite links do not expire and anyone who gets access to the link can join a
team. You can prevent this by setting up [SSO](/account/teams/sso)
### Remove member
Admins can remove members at any time by clicking the context menu and then "Remove". We'll only charge for time the member was in the team
### Change role
Admins can change roles for other members by clicking the context menu and then "Change role". There has to be at least one Admin per team
## Security & SSO
SAML 2.0 Single Sign-On (SSO) is available on Business and Enterprise plans. Key features:
* Configure SSO connections ([learn more about SSO setup](/account/teams/sso))
* Set up domain verification
* Automatic user enrollment through SSO
* SSO enforcement options
* Identity provider integration (Okta, etc)
## Usage Controls
Access usage settings to:
* Enable usage-based pricing
* Enable for usage-based for premium models
* Set admin-only modifications for usage-based pricing settings
* Set monthly spending limits
* Monitor team-wide usage
## Billing
When adding new team members:
* Each new member or admin adds a billable seat (see [pricing](https://cursor.com/pricing))
* Seat changes are prorated for your billing period
* Unpaid admin seats are not counted
Adding new team members in the middle of a month, we'll only charge you for the days they actually use. Similarly, if someone leaves the team, we'll credit your account for any unused days.
If you change someone's role (e.g from Admin to Unpaid Admin), we'll automatically adjust the billing from the day of the change. You can choose to be billed either monthly or yearly - both options are available to suit your needs.
### Switching from monthly to yearly billing
You can save 20% of the Business plan by switching from monthly to yearly billing. This can be done from the [dashboard](/account/dashboard)
1. Go to [settings](https://cursor.com/settings)
2. In the account section, click on "Advanced" then "Upgrade to yearly billing"
Please note that you can only switch from monthly to yearly billing
self-service. To switch from yearly to monthly billing, please contact us at
[hi@cursor.com](mailto:hi@cursor.com).
# Setup
Source: https://docs.cursor.com/account/teams/setup
Learn how to create and manage a business team: setup, invite members, and configure SSO options
## Creating a team
To create a team, you need to be on the [Business plan](/account/plans).
If you're setting up a new account, head over to [create team](https://cursor.com/team/new-team). If you're on a Pro plan, you can click the "Upgrade to Business" button in [dashboard](/account/dashboard)
After clicking "New Team", enter the details for the team. You will have to
select name and billing cycle for the team
After the team is created, you can start inviting members to the team. All
changes to users are prorated, meaning that we will only charge for the time
that a user has been a member of the team
After the team is created, you can enable [SSO](/account/teams/sso) for the team for additional security.
## FAQ
### How can I purchase 10 licenses for my company?
Start by creating a team, then invite your team members. We charge based on the amount of users in your team. We don't have a fixed amount of seats, it's prorated as you update team members
### How can I set up a team when I'm not going to use Cursor myself?
We require at least one paid member to create a team. If you are creating the team, we require you to start as a paid member. After you've invited another member to the team, you can assign yourself the [Unpaid Admin role](/account/teams/members). Seat changes are not billed immediately, so you can set up a team, invite a member and change your own role without being charged
### How can I add Cursor to an MDM, like Kandji?
You can get the versions from here:
* Mac: [Apple Silicon](https://downloader.cursor.sh/mac/dmg/arm64)
* Mac: [Intel](https://downloader.cursor.sh/mac/dmg/x64)
* Windows: [x64](https://downloader.cursor.sh/windows/nsis/x64)
* Windows: [arm64](https://downloader.cursor.sh/windows/nsis/arm64)
Then follow the instructions for your MDM:
* Kandji: [Custom Apps](https://support.kandji.io/kb/custom-apps-overview)
# SSO
Source: https://docs.cursor.com/account/teams/sso
Learn how to set up SAML 2.0 Single Sign-On (SSO) for secure team authentication in Cursor
## Overview
SAML 2.0 Single Sign-On (SSO) is available on the Cursor Business plan. This guide walks through the configuration process and helps you set up secure authentication for your team.
## Prerequisites
* A Cursor Business plan
* Admin access to your identity provider (e.g., Okta)
* Admin access to your Cursor organization
## Configuration Steps
1. Sign in to your Cursor account and navigate to [cursor.com/settings](http://cursor.com/settings)
2. Locate the "Configure SSO" button in the bottom left of the settings page
3. Click the button to begin the SSO setup process
4. In your identity provider (e.g., Okta):
* Create a new SAML application
* Configure the SAML settings using the information provided in Cursor
* Set up Just-in-Time (JIT) provisioning for seamless user access
### Identity Provider Setup Guides
For detailed setup instructions specific to your identity provider, refer to the [WorkOS integration guides](https://workos.com/docs/integrations).
SCIM provisioning coming H1 2025
## Additional Settings
* SSO enforcement is managed through the admin dashboard
* New users are automatically enrolled in your organization when they sign in through SSO
* User management can be handled directly through your identity provider
## Troubleshooting
If you encounter issues during setup:
* Verify your domain has been verified in Cursor
* Ensure all required SAML attributes are properly mapped
* Check that the SSO configuration is enabled in your admin dashboard
* If a user is unable to authenticate, ensure the first and last name set in the identity provider matches their name in Cursor
# Usage
Source: https://docs.cursor.com/account/usage
Learn how Cursor handles fast and slow request pools, pricing, and monthly request allocation
### Fast and Slow Requests
There are two types of requests in Cursor, **slow** and **fast** that has its own pool
By default, Cursor servers try to give all users fast `premium` model requests. However, when users run out of fast `premium` credits, they are moved to a slow pool. Wait times in the slow pool are calculated proportionally to how many slow requests you've used, so they generally remain manageable unless you're well over your fast request limit.
To bypass wait times entirely, you cana enable usage-based pricing (you'll only be charged for requests beyond your included fast requests)
See [models](/settings/models) for an overview of which models are `premium` and their alternatives
### Included requests
Every subscription includes a set amount of fast requests. See [plans](/account/plans.mdx) for details on how many fast requests your subscription includes.
### Additional requests
We offer usage-based pricing for additional requests beyond your plan's included quota:
#### Usage-based Pricing
You may opt in to usage-based pricing for requests that go beyond what is included in your Pro or Business plan from your [dashboard](/account/dashboard)
Usage-based pricing is only available with a paid subscription.
From the dashboard, you can toggle usage based pricing for `premium` models and `other` models (see [models](/settings/models) to understand which model is which). You can also configure a spend limit in USD to make sure you never go over that. Once the spending limit is hit, slow requests will be used.
We will bill for additional fast requests when you’ve made requests totaling \$20, **or** on the 2nd or 3rd day of the month, whichever comes first.
375 fast requests made with a `premium` model (\$15) will be billed at the beginning of the next month since the total value is under \$20
1150 fast requests made with a `premium` (\$46) will be billed 3 times:
1. When first batch of 500 requests has been made (\$20)
2. When second batch of 500 requests has been made (also \$20)
3. Beginning of next month (remaining \$6)
For team accounts, administrators can restrict usage-based pricing settings to admin-only access
Cost per request for each model can be found on the [models](/settings/models) page
#### Fast requests packages (deprecated)
Fast requests packages have been deprecated. Existing users with additional packages can continue to use them and have the option to remove them, but new packages cannot be purchased. If you are at the base amount of fast requests packages, the option to modify them will no longer be available in the dashboard.
### FAQ
#### When do my fast requests reset?
Your Fast Requests reset on a fixed monthly date based on when you first set up your plan. If you purchase additional requests (for example, upgrading from 500 to 1000 requests), the reset date remains unchanged. For instance, if your plan started on the 23rd, your requests will always reset on the 23rd of each month, regardless of when you purchase additional requests.
#### What does "500 premium requests" mean for teams?
Each user gets their own quota of 500 fast requests for premium models per month. These requests are not pooled across the team - every team member gets their own fresh 500 requests when their personal monthly cycle resets.
# Agent
Source: https://docs.cursor.com/agent
AI assistant that uses tools and reasoning to perform coding tasks with minimal supervision
You can delegate tasks to Cursor Agent and let it work alongside you. Agent performs its work in [Composer](/composer) and is built on top of it. Make sure to read about [Composer](/composer) to best work with Agent.
## Tools
Agent has access to multiple tools, including
* Reading & Writing code
* Searching codebase
* Call [MCP](/context/model-context-protocol) servers
* Run terminal commands
The reasoning capabilities of Agent enables some very powerful workflows where it can perform many consecutive actions without much supervision.
Agent can make up to 25 tool calls before stopping. If you need more, just ask
it to continue
### Terminal
When Agent runs terminal commands, it uses VS Code's terminal profiles to determine which shell to use. It iterates through the available profiles, starting with the default one, and selects the first profile that supports command detection. This means the shell used by Agent might differ from your default system shell if another compatible terminal profile is found first.
To change which terminal profile is used:
1. Open Command Palette (`Cmd/Ctrl+Shift+P`)
2. Search for "Terminal: Select Default Profile"
3. Select your preferred terminal profile
## Yolo mode
With Yolo mode enabled, Agent can execute terminal commands by itself. This especially useful when running test suites. Instruct Agent with a task and how to verify changes (running a test), and it will continue until the task is completed.
### Guardrails
You can define guardrails and allow/deny lists for certain commands you don't want Agent to run automatically. This is done from Cursor Settings
## Rules
You can direct the Agent with [rules](/context/rules-for-ai). They can auto attached to any Agent request based on glob patterns, or the Agent can grab one based on the rule description.
Read more about how you can [work with rules](/context/rules-for-ai)
## Use Agent
Start by opening a new Composer and enable Agent mode. From there, you can give it instructions on what work to perform.
## Models
You can use `claude-3.5-sonnet`, `gpt-4o` and `o3-mini` with Agent today. We'll be adding more models soon!
## FAQ
### What's the difference between Agent and Composer?
You can toggle between Normal and Agent mode in Composer. The main difference is that Agent will think harder, use reasoning and tools to solve problems thrown at it. Normal composer doesn't have access to tools, only managing code.
# Notepads
Source: https://docs.cursor.com/beta/notepads
A guide to using Notepads in Cursor for sharing context between Composers and Chat interactions
Notepads are currently in beta and subject to be deprecated in the future.
# Overview
Notepads are powerful context-sharing tools in Cursor that bridge the gap between composers and chat interactions. Think of them as enhanced reference documents that go beyond the capabilities of `.cursorrules`, allowing you to create reusable contexts for your development workflow.
Notepads serve as collections of thoughts, rules, and documentation that can be:
* Shared between different parts of your development environment
* Referenced using the `@` syntax
* Enhanced with file attachments
* Used as dynamic templates for various development scenarios
## Getting started
1. Click the "+" button in the Notepads section
2. Give your notepad a meaningful name
3. Add your content, context, files and other relevant information the same way you would in composer or chat.
4. Reference it in composers or chat using `@`
# Key features
* **Context Sharing**: Seamlessly share context between composers and chat
* **File Attachments**: Attach documentation and reference files (not possible in `.cursorrules`)
* **Dynamic References**: Use `@` mentions to link to other resources
* **Flexible Content**: Write and structure information in a way that suits your needs
# Common use cases
1. **Dynamic Boilerplate Generation**
* Create templates for common code patterns
* Store project-specific scaffolding rules
* Maintain consistent code structure across your team
2. **Architecture Documentation**
* Frontend specifications
* Backend design patterns
* Data model documentation
* System architecture guidelines
3. **Development Guidelines**
* Coding standards
* Project-specific rules
* Best practices
* Team conventions
## FAQ
### What should I write in Notepads?
Notepads are ideal for:
* Project architecture decisions
* Development guidelines and standards
* Reusable code templates
* Documentation that needs to be referenced frequently
* Team-specific conventions and rules
### What should not be written in Notepads?
Avoid using Notepads for:
* Temporary notes or scratch work
* Information that belongs in version control (like git)
* Sensitive data or credentials
* Highly volatile information that changes frequently
### Should I follow a particular format or structure?
While Notepads are flexible, we recommend:
* Using clear headings and sections
* Including examples where relevant
* Keeping content focused and organized
* Using markdown formatting for better readability
* Adding relevant file attachments when necessary
### Example Notepad
Here's a typical example of a Notepad for a web application project:
```md Notepad example
# API Development Guidelines
## Endpoint Structure
- Use RESTful conventions
- Base URL: `/api/v1`
- Resource naming in plural form
## Authentication
- JWT-based authentication
- Token format: Bearer {token}
- Refresh token mechanism required
## Response Format
{
"status": "success|error",
"data": {},
"message": "Optional message"
}
## Attached References
@api-specs.yaml
@auth-flow.md
```
# Apply
Source: https://docs.cursor.com/chat/apply
Learn how to apply, accept, or reject code suggestions from chat using Cursor's Apply feature
Cursor's `Apply` allows you to quickly integrate a codeblock suggestion from the chat into your code.
## Apply Code Blocks
To apply a code block suggestion, you can press on the play button in the top right corner of each chat code block.
This will edit your file to incorporate the code produced by Chat. Since you can add the most context and have the most back-and-forth with the model in Chat,
we recommend Chat + Apply for more complex AI-driven code changes.
## Accept or Reject
Once you have applied a code block, you can go through the diffs and accept or reject the changes. You can also click
on the "Accept" or "Reject" buttons in the top right corner of the chat code block.
`Ctrl/⌘ Enter` to accept, `Ctrl/⌘ Backspace` to reject.
# With Codebase
Source: https://docs.cursor.com/chat/codebase
Learn how Chat searches codebases using default search, embeddings, and advanced @Codebase queries.
## Default Codebase Chat
If a codebase isn't [indexed](/context/codebase-indexing), Chat will first attempt to compute a few search queries to
be used to search across your codebase. For better accuracy, it's recommended to use [embeddings search](#embeddings-search).
## Embeddings Search
With [codebase indexing](/context/codebase-indexing), Chat can accurately generate responses based on your codebase.
By pressing `Ctrl/⌘ + Enter` after typing a message, Chat scans through your indexed codebase to find pieces of relevant code. This is generally
good for quickly including code snippets to be taken into the context of the conversation. For more control over the codebase search and better accuracy,
you can use `@codebase`.
## Advanced Codebase Search
Cursor codebase chat goes through a more detailed search when `@Codebase` is used.
See more about `@Codebase` [here](/context/@-symbols/@-codebase).
# Customize
Source: https://docs.cursor.com/chat/customize
Learn how to open Chat as an editor tab and use keyboard shortcuts to access it quickly
## In-Editor
Chat can also be used as an editor tab by clicking on the horizontal "More" button, and then clicking on the "Open Chat in Editor" button.
Chat will then behave as a regular editor tab. Pressing `Ctrl/⌘ + L` will bring up the chat tab and focus onto it.
# Overview
Source: https://docs.cursor.com/chat/overview
Chat feature that uses AI to answer code questions with smart context and file references in your editor
Chat lets you ask questions or solve problems in your codebase with the most capable language models, all in your editor.
For language models to give good answers, they need to know specific things that are relevant to your codebase -- context.
Cursor has several built-in features to provide context in chat, such as automatically including context across your entire codebase, searching the web, indexing documentation, and user-specified references to code blocks. These features are built to eliminate the tedious copy-pasting otherwise necessary for working with language models on code.
By default, Chat is in the AI pane, which is on the opposite side of your primary sidebar. You can toggle the AI pane by pressing `Ctrl/⌘ + L`, which focuses onto the chat when opened.
To submit your query, press `Enter`.
## User and AI Messages
User messages contain the text you type, along with the context you've referenced. You can go back to any previous user messages to edit and rerun your queries. This will
overwrite any messages after that and regenerate new ones.
AI messages are the responses generated from the AI model you've picked. They are paired with the user message before them. AI messages may contain parsed code blocks which can be added to your codebase with [instant apply](/chat/apply).
All user/AI messages together in the same thread are called a chat thread, and each chat thread is saved in your chat history.
## Chat History
By pressing the "Previous Chats" button on the top right of the AI pane, or by pressing `Ctrl/⌘ + Alt/Option + L`, you can see the chat history. You can click on any chat thread to go back and see the messages that make up that thread,
and you can also modify the title of the thread by clicking the pen icon, or delete the thread by clicking the garbage can icon upon hovering over the thread in the history.
The title of a Cursor thread is just the first few words of the first user message.
## Default Context
By default, Chat includes the current file as context. You can submit a query without including any context by removing the current file pill from the message.
As you type, you can see what will be included in context in the pills above the input box.
## Adding Context
By default, user messages will contain the text you type, along with the context you've referenced. You can add more custom context to each bubble with @ symbols, and by default, the current viewing file will be used as context as well in the user message.
See the [@ symbols](/context/@-symbols/@-files) pages for more information.
## AI Fix in Chat
A convenient feature to fix linter errors in your codebase is to use the AI fix in chat. To do this, hover over the error in the editor, and click the blue AI fix button that shows up.
The keyboard shortcut for this would be to do `Ctrl/⌘ + Shift + E`.
# Overview
Source: https://docs.cursor.com/cmdk/overview
Learn how to use Cmd/Ctrl K in Cursor to generate, edit code and ask questions with the Prompt Bar
Cmd K, also known or "Ctrl K" on Windows/Linux, allows you to generate new code or edit existing code in the editor window.
## Prompt Bars
In Cursor, we call the bar that appears when you press `Ctrl/Cmd K` the "Prompt Bar". It works similarly to the AI input box for chat, in
which you can type normally, or use [@ symbols](context/@-symbols) to reference other context.
## Inline Generation
If no code is selected when you press `Ctrl/Cmd K`, Cursor will generate new code based on the prompt you type in the prompt bar.
## Inline Edits
For in-place edits, you can simply select the code you want to edit and type into the prompt bar.
## Follow-up Instructions
After each generation, you can further refine the prompt by adding more instructions to the prompt bar, and pressing `Enter` so the AI regenerates based on your follow-up instructions.
## Default Context
By default, Cursor will try to find different kinds of useful information to improve code generation, in addition to the manual [@ symbols](/context/@-symbols/@-files) you include.
Additional context may include related files, recently viewed files, and more. After gathering, Cursor ranks the context items by relevance to your edit/generation
and keeps the top items in context for the large language model.
## Quick Question
If you press `Option/Alt Enter` while in the prompt bar, Cursor will respond to any questions you have about the selection, and the context you have attached.
The contents of this conversation could be further used in follow-up generations, so you could simply type "do it" after Cursor comes up with a response to generate the code after a quick question.
# Terminal Cmd K
Source: https://docs.cursor.com/cmdk/terminal-cmdk
Use Ctrl/⌘ K in Cursor terminal to generate and run commands through a prompt bar interface
In the built-in Cursor terminal, you can press `Ctrl/⌘ K` to open a prompt bar on the bottom of the terminal.
This prompt bar allows you to describe your desired action in the terminal, and terminal Cmd K will generate a command.
You can accept the command by hitting `esc` or run the command immediately with `Ctrl/⌘ + Enter`.
By default, Terminal Cmd K sees your recent terminal history, your instructions, and anything else you put in the prompt bar as context.
# Composer
Source: https://docs.cursor.com/composer
AI coding assistant that helps write and edit code directly in your editor with chat and agent modes
Composer is your AI coding assistant that lives in your editor. It helps you explore code, write new features, and modify existing code without leaving your workflow. Use `⌘I` to open it, and `⌘N` to create a new Composer.
## Modes
Composer can be used in two different modes
Read and writes code. Usually faster. Works with all models
Reasoning capabilities and access to tools to call MCP servers, run
terminal commands and manage code
## Context
You can use [@-symbols](/context/@-symbols/basic) to include relevant context in your prompts
## Generating & Applying Changes
When Composer suggests changes:
* Review them in the diff view
* Accept or reject changes with the buttons provided
* Use checkpoints to undo if needed
## Checkpoints
For every iteration a checkpoint is created. You can return to any previous version by clicking on `checkout` near that checkpoint. This is handy if you don't like the current changes and want to revert to an earlier state.
## History
Access previous Composer sessions and chats through the history. Open it from the history icon to the right of Cursor Tab. You'll see a list of past composers and chats, which you can revisit, rename, or remove.
Open with `⌘+⌥+L` or `Ctrl+Alt+L` when Composer is focused.
## Layout
* **Pane**: A sidebar with chat on the left and your code editor on the right.
* **Editor**: A single editor window, similar to viewing code normally. You can move it around, split it, or even place it in a separate window.
* **Floating**: A draggable window that you can position where you like
You can change this from the Composer menu > Open as \[layout]
## Iterate on lints
Composer attempts to fix linting issues in generated code for most programming languages. If Composer detects lint errors, it will try to fix them automatically when this feature is enabled. Currently, only one iteration is supported.
Some languages (like Rust) require files to be saved before lint errors
appear, which may limit this feature's effectiveness in all languages.
## FAQ
### What's the difference between Chat and Composer?
Chat helps you search and understand your code. Use it to explore your codebase, ask questions, and get explanations. You can search your code with `⌘⏎`.
Composer helps you write and edit code. It provides a workspace where you can generate new code and apply changes directly to your files.
### How are long conversations handled?
For long conversations, Cursor summarize earlier messages with smaller models like `cursor-small` and `gpt-4o-mini` to keep responses fast and relevant.
This approach helps ensure that even extended conversations remain responsive and coherent, without losing track of key details from earlier exchanges.
### Can I access my Composer history on another computer?
Composer history is stored locally on your computer and is not stored on Cursor's servers or tied to your Cursor account.
This means if you switch to a different computer, you won't have access to your previous Composer history. You can only access your Composer history on the computer where it was originally created.
# @Code
Source: https://docs.cursor.com/context/@-symbols/@-code
Learn to reference code using @Code symbol and keyboard shortcuts for adding code to Chat or Edit
To reference specific sections of code, you can use the `@Code` symbol.
## Code Preview
Similar to the [`@Files`](/context/@-symbols/@-files) symbol, Cursor will show a preview of the code's content so you can verify that the code you're referencing is the correct one.
## From the Editor
Another way to add code snippets as context is to select the code you want to reference, and click on either "Add to Chat" (`Ctrl/⌘ Shift L`) or "Add to Edit" (`Ctrl/⌘ Shift K`).
These will add the selected code snippet to either the Chat input box or the currently active Cmd K prompt bar.
To add a selected code to a new chat, you can press `Ctrl/⌘ L`.
# @Codebase
Source: https://docs.cursor.com/context/@-symbols/@-codebase
Learn how Chat processes codebase queries using gathering, reranking, reasoning, and generation steps
Through `@Codebase`, Chat goes through these steps until it finds the most important pieces of code to use.
* Gathering: scanning through your codebase for important files / code chunks
* Reranking: reordering the context items based on relevancy to the query
* Reasoning: thinking through a plan of using the context
* Generating: coming up with a response
Another way of submitting an advanced codebase query is to click on the dropdown next to the `Ctrl/⌘ + Enter` button and select `reranker` for the search behavior.
This is only available when `@Codebase` isn't used, otherwise `@Codebase` takes precedence.
# @Cursor Rules
Source: https://docs.cursor.com/context/@-symbols/@-cursor-rules
Work with and reference Cursor rules in your project
The `@Cursor Rules` symbol provides access to [project rules](/context/rules-for-ai#project-rules-recommended) and guidelines you've set up for your project, allowing you to explicitly apply them to your context.
# @Definitions
Source: https://docs.cursor.com/context/@-symbols/@-definitions
Add nearby code definitions to Cmd K context using the @Definitions symbol
This feature is currently only for Cmd K.
The `@Definitions` symbol adds all nearby definitions to Cmd K as context.
# @Docs
Source: https://docs.cursor.com/context/@-symbols/@-docs
Learn how to use, add, and manage custom documentation as context in Cursor using @Docs
Cursor comes with a set of third party docs crawled, indexed, and ready to be used as context. You can access them by using the `@Docs` symbol. You can find a list of our default pre-scraped docs [here](https://raw.githubusercontent.com/getcursor/crawler/main/docs.jsonl).
## Add Custom Docs
If you want to crawl and index custom docs that are not already provided, you can do so by `@Docs` > `Add new doc`.
The following modal will appear after you've pasted in the URL of your desired doc:
Cursor will then index and learn the doc, and you will be able to use it as context like any other doc. Make sure to add a trailing slash to the URL if you want to index all subpages and subdirectories
## Manage Custom Docs
Under `Cursor Settings` > `Features` > `Docs`, you will see the docs you have added.
You can edit, delete, or add new docs here.
# @Files
Source: https://docs.cursor.com/context/@-symbols/@-files
Learn how to reference files using @ in Cursor's Chat and Cmd K, with preview and chunking features
In AI input boxes such as in Chat and Cmd K, you can reference entire files by using `@Files`.
Also, if you continue to type after `@`, you will see your file search results after the [`@Code`](/context/@-symbols/@-code) strategy.
In order to make sure the file you're referencing is the correct file, Cursor will show a preview of the file's path. This is especially useful when you have multiple files with the same name in different folders.
### Chat Long File References
In Cursor's Chat, if the contents of a file is too long, Cursor will chunk the file into smaller chunks and rerank them based on relevance to the query.
{/*
commenting this out, not in product anymore afaik // ez 2025-02-09
### Cmd K Chunking Strategy
For Cmd K, Cursor uses the file references differently based on the content length as well.
- auto
- Automatically pick one of the three reading strategies based on the file size
- full file
- The entire file is used as context.
- outline
- Cursor parses the outline of the file and uses the information as context.
- chunks
- Cursor chunks the file into smaller chunks and picks the most relevant one.
*/}
### Drag and Drop
You can drag and drop files from the primary sidebar into Composer, Chat or Cmd K to add them as context.
# @Folders
Source: https://docs.cursor.com/context/@-symbols/@-folders
Reference folders as context in Chat & Composer for enhanced AI conversations
You can reference entire folders in Cursor as context. When using `@Folders` with Agent, it attaches a list of all items in the directory, which allows the Agent to search through the contents itself. This gives Agent the ability to explore and analyze the folder's contents independently as needed for the task at hand.
# @Git
Source: https://docs.cursor.com/context/@-symbols/@-git
Learn how to use @Git in Cursor's Chat to analyze diffs, find bugs, and generate commit messages
Currently, `@Git` is only supported in Chat & Composer
In Cursor's Chat, you can use `@Git` to add git commits, diffs, or pull requests to your prompt.
## Common Use Cases
One common use case for `@Git` is to allow Cursor's AI to scan the diff and look for bugs or issues that could be caused by the diff.
You could also use `@Diff of Working State` to generate a commit message from your current diffs.
# @Link
Source: https://docs.cursor.com/context/@-symbols/@-link
Use web content as context by linking to external websites and resources
## Paste Links
In order for Cursor to visit a link before paste the link and you'll see that the link is "tagged"
## Remove Links
By default, we automatically parse links and turn them into `@Links` in Chat.
If you prefer to have the link as plain text, click on the link and then click `Unlink`.
You can also paste without formatting (hold `Shift`) to make sure the link is not tagged
# @Lint Errors
Source: https://docs.cursor.com/context/@-symbols/@-lint-errors
Access and reference linting errors in your codebase
The `@Lint Errors` symbol automatically captures and provides context about any linting errors and warnings from your currently active file.
[Composer](/composer) and [Agent](/agent) can see lint errors by default
# @Notepads
Source: https://docs.cursor.com/context/@-symbols/@-notepads
Reference and include notepads as context in Cursor
The `@Notepads` symbol allows you to reference and include your [Notepads](/beta/notepads) as context in your conversations. Notepads are powerful context-sharing tools that bridge the gap between composers and chat interactions, allowing you to create reusable contexts for your development workflow.
# @Recent Changes
Source: https://docs.cursor.com/context/@-symbols/@-recent-changes
Access and reference recent changes in your workspace
Cursor automatically keeps track of recent changes made to your codebase. The `@Recent Changes` symbol allows you to pass these modifications as context
# @Summarized Composers
Source: https://docs.cursor.com/context/@-symbols/@-summarized-composers
Reference summarized versions of your previous Composer sessions as context in new conversations
When working on complex tasks in [Composer](/composer), you might want to reference context or decisions from previous conversations. The `@Summarized Composers` symbol allows you to include summarized versions of your previous Composer sessions as context.
This is particularly useful when:
* You have a long Composer session with important context you want to reference
* You're starting a new but related task and want to maintain continuity
* You want to share the reasoning or decisions from a previous session
# @Web
Source: https://docs.cursor.com/context/@-symbols/@-web
@Web command searches the internet automatically to find relevant context for Cursor queries
## `@Web`
With `@Web`, Cursor constructs a search query based on the query and the context you've provided, and searches the web to
find relevant information as additional context.
This can be useful to allow Cursor to find the most up-to-date information online, or to allow Cursor to scrape multiple websites in a few seconds to find the best answer, without the user having to manually search anywhere.
# Overview
Source: https://docs.cursor.com/context/@-symbols/overview
Overview of all @ symbols available in Cursor for context and commands
In Cursors input boxes, such as in Composer, Chat and Cmd K, you can use @ symbols by typing `@`. A popup menu will appear with a list of suggestions,
and it will automatically filter to only show the most relevant suggestions based on your input.
## Keyboard Shortcuts
You can navigate through the list of suggestions using the up/down arrow keys. You can hit `Enter` to select a suggestion. If the suggestion is a category, such as `Files`,
the suggestions will be filtered to only show the most relevant items within that category.
Here's the list of all @ symbols available:
* [@Files](/context/@-symbols/@-files) - Reference specific files in your project
* [@Folders](/context/@-symbols/@-folders) - Reference entire folders for broader context
* [@Code](/context/@-symbols/@-code) - Reference specific code snippets or symbols from your codebase
* [@Docs](/context/@-symbols/@-docs) - Access documentation and guides
* [@Git](/context/@-symbols/@-git) - Access git history and changes
* [@Notepads](/context/@-symbols/@-notepads) - Access notepads
* [@Summarized Composers](/context/@-symbols/@-summarized-composers) - Work with summarized composer sessions
* [@Cursor Rules](/context/@-symbols/@-cursor-rules) - Work with cursor rules
* [@Web](/context/@-symbols/@-web) - Reference external web resources and documentation
* [@Link (paste)](/context/@-symbols/@-link) - Create links to specific code or documentation
* [@Recent Changes](/context/@-symbols/@-recent-changes) - Create links to specific code or documentation
* [@Codebase](/context/@-symbols/@-codebase) - Reference your entire codebase as context ([Chat](/chat/overview) only)
* [@Lint Errors](/context/@-symbols/@-lint-errors) - Reference lint errors ([Chat](/chat/overview) only)
* [@Definitions](/context/@-symbols/@-definitions) - Look up symbol definitions ([Cmd K](/cmdk/overview) only)
There are also some other symbols that can be used:
* [# Files](/context/@-symbols/pill-files) - Add files to the context without referencing
* [/ Commands](/context/@-symbols/slash-commands) - Add open and active files to the context
# #Files
Source: https://docs.cursor.com/context/@-symbols/pill-files
Use # to select files and @ for context control when chatting with AI agents
Use `#` followed by a filename to focus on specific files. Combine this with `@` symbols for precise context control.
# /command
Source: https://docs.cursor.com/context/@-symbols/slash-commands
Use / to reference open editor tabs and add them as context when composing chats with the AI agent
You type `/`to quickly reference open editors and add them as context
* **Open editors**: All editors tabs currently open
* **Active editors**: All editor tabs in view. This is typically when splitting the layout to show multiple editors
# Codebase Indexing
Source: https://docs.cursor.com/context/codebase-indexing
Learn how to index your codebase in Cursor for more accurate AI assistance and search results
### Index your Codebase
For better and more accurate codebase answers, you can index your codebase. Behind the scenes, Cursor
computes embeddings for each file in your codebase, and will use these to improve the accuracy of your codebase answers.
Cursor maintains separate codebase indexes for each user. After you complete the initial indexing setup, Cursor will automatically index any new files added to your workspace to keep your personal codebase context current.
The status of your codebase indexing is under `Cursor Settings` > `Features` > `Codebase Indexing`.
### Advanced Settings
By default, Cursor will index all files in your codebase.
You can also expand the `Show Settings` section to access more advanced options.
Here, you can decide whether you want to enable automatic indexing for new repositories and configure the files
that Cursor will ignore during repository indexing.
Cursor uses the same package as VS Code to handle file ignoring, which means it respects all `.gitignore` files, including those in subdirectories. You can also create a `.cursorignore` file for user-specific ignore patterns, which you may want to add to your global `.gitignore` to avoid committing it to the repository.
If you have any large content files in your project that the AI definitely doesn't need to read, [ignoring those files](/context/ignore-files) could improve the accuracy of the answers.
### Working with large monorepos
When working with large monorepos containing hundreds of thousands of files, it's important to be strategic about what gets indexed.
* Use `.cursorignore` to let each developer configure which folders and paths they work on in the monorepo
* Add `.cursorignore` to your global `.gitignore`
This allows each developer to optimize indexing for their specific work areas within the monorepo.
## FAQ
### Where can I see all codebases I have indexed?
Currently, there is no way to see a list of all codebases you have indexed. You'll need to manually check each project's indexing status by opening the project in Cursor and checking the Codebase Indexing settings.
### How do I delete all codebases?
You can either delete your Cursor account from Settings to remove all indexed codebases, or manually delete individual codebases from the Codebase Indexing settings in each project. There's currently no way to delete all codebases at once without deleting your account.
# Ignore Files
Source: https://docs.cursor.com/context/ignore-files
Learn how to use .cursorignore to exclude files from codebase indexing, similar to .gitignore
## About `.cursorignore`
To ignore files from being included in [codebase indexing](/context/codebase-indexing), you
can use a `.cursorignore` file in the root of your project. It works the same way as `.gitignore` works for git.
`.cursorignore` respects `.gitignore`. If you already have `.gitignore`, the files will be ignored by default.
If you want to ignore additional files, you can add them to the `.cursorignore` file.
You can read more about how this works on our [security page](https://www.cursor.com/security).
## Chat and Composer Context
Currently, Chat and Composer have access to all files in their context, regardless of `.cursorignore` settings.
More info on how we handle AI requests can be found on our [security page](https://www.cursor.com/security#ai-requests).
## Example `.cursorignore` files
### Ignore specific files
```sh
# Ignore all files in the `dist` directory
dist/
# Ignore all `.log` files
*.log
# Ignore specific file `config.json`
config.json
```
### Only include specific files
Include only `*.py` files in the `app` directory. Note that this is the same syntax as `.gitignore`.
```sh
# ignore everything
*
# do not ignore app
!app/
# do not ignore directories inside app
!app/*/
!app/**/*/
# don't ignore python files
!*.py
```
## Troubleshooting
The ignore file syntax is sometimes a bit confusing. The `.cursorignore` file follows the exact same syntax as `.gitignore`, so if you are trying an ignore file and it doesn't work the way you expect it to, we recommend a Google search for the issue, replacing `cursorignore` in your search query with `gitignore`. Probably someone will had the same issue and StackOverflow will have a good answer.
One common example: [here's how you ignore all files except those with a `.php` extension](https://stackoverflow.com/a/50606028) (just adding `*` followed by `!*.php` does not work because the gitignore file discoverer will not descend into and discover any `.php` files in subdirectories).
# Model Context Protocol
Source: https://docs.cursor.com/context/model-context-protocol
Learn how to add and use custom MCP tools with the Agent in Cursor's Composer feature
The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) is an open protocol that allows you to provide custom tools to agentic LLMs in Cursor.
MCP tools may not work with all models. MCP tools are only available to the
Agent in Composer.
Cursor implements an MCP client, which supports an arbitrary number of MCP servers.
Cursor's MCP client supports the `stdio` and `sse` transports.
## Adding an MCP Server to Cursor
To add an MCP server to Cursor, go to `Cursor Settings` > `Features` > `MCP` and click on the `+ Add New MCP Server` button.
This will open a modal with a form to fill out. Select the transport under `Type`, and fill out a nickname for the server (`Name`) either the command to run or the URL of the server, depending on the transport.
For example, this is how you would configure the [MCP quickstart weather server](https://github.com/modelcontextprotocol/quickstart-resources/tree/main/weather-server-typescript), assuming it has already been built and placed at ` ~/mcp-quickstart/weather-server-typescript/build/index.js`. The entire command string in this case is `node ~/mcp-quickstart/weather-server-typescript/build/index.js`.
And this is how you would configure the [MCP sample tool](https://github.com/modelcontextprotocol/python-sdk/tree/main/examples/servers/simple-tool), assuming it is running locally on port `8765`.
For SSE servers, the URL should be the URL of the SSE endpoint, e.g. `http://example.com:8000/sse`.
For stdio servers, the command should be a valid shell command that can be run from the terminal.
If you require environment variables to be set, we recommend you write a small wrapper script that sets the environment variables and then runs the server.
After adding the server, it should appear in the list of MCP servers. You may have to manually press the refresh button in the top right corner of the MCP server in order to populate the tool list. Here is what the tool list would look like after loading a (modified version of) the weather and sample servers.
### Managing MCP servers
MCP servers can be edited or deleted from the MCP settings page.
## Using MCP Tools in Composer
The Composer Agent will **automatically** use any MCP tools that are listed under `Available Tools` on the MCP settings page if it determines them to be relevant.
To prompt tool usage intentionally, simply tell the agent to use the tool, referring to it either by name or by description.
When the agent decided to use a tool, it will display a message in the chat like the following, prompting the user to approve or deny the tool call.
The user can expand the message to see the tool call arguments.
If the user approves the tool call, the agent will use the tool and display the response in the chat.
This image shows the response from the sample tool, as well as expanded views of the tool call arguments and the tool call response.
# Rules for AI
Source: https://docs.cursor.com/context/rules-for-ai
Learn how to customize AI behavior in Cursor using project-specific and global rules
Using rules in Cursor you can control the behavior of the underlying model. You can think of it as instructions and/or a system prompt for LLMs.
## Project Rules (recommended)
Project rules offer a powerful and flexible system with path specific configurations. Project rules are stored in the `.cursor/rules` directory and provide granular control over AI behavior in different parts of your project.
Here's how they work
* **Semantic Descriptions**: Each rule can include a description of when it should be applied
* **File Pattern Matching**: Use glob patterns to specify which files/folders the rule applies to
* **Automatic Attachment**: Rules can be automatically included when matching files are referenced
* **Reference files**: Use @file in your project rules to include them as context when the rule is applied.
You can reference rule files using @file, allowing you to chain multiple rules
together
You can create a new rule using the command palette with `Cmd + Shift + P` > `New Cursor Rule`. By using project rules you also get the benefit of version control since it's just a file
Example use cases:
* Framework-specific rules for certain file types (e.g., SolidJS preferences for `.tsx` files)
* Special handling for auto-generated files (e.g., `.proto` files)
* Custom UI development patterns
* Code style and architecture preferences for specific folders
## Global Rules
Global rules can be added by modifying the `Rules for AI` section under `Cursor Settings` > `General` > `Rules for AI`. This is useful if you want to specify rules that should always be included in every project like output language, length of responses etc.
## `.cursorrules`
For backward compatibility, you can still use a `.cursorrules` file in the root of your project. We will eventually remove .cursorrules in the future, so we recommend migrating to the new Project Rules system for better flexibility and control.
# FAQ
Source: https://docs.cursor.com/faq
Frequently asked questions about Cursor's features, language support, models, and usage
While Cursor works with any programming language, it excels with Python and JavaScript/TypeScript due to extensive model training data. It also performs well with Swift, C, and Rust. You can enhance support for any language by adding relevant documentation to your project.
Cursor leverages powerful foundational models like Claude 3.5 and GPT-4. For the most current library information, you can use our [@web](/context/@-symbols/@-web) search feature. Since core language concepts rarely change dramatically, the models maintain their effectiveness over time.
The MCP server serves as a bridge for bringing external context into Cursor. It enables connections to services like Google Drive and Notion, helping you incorporate documentation and requirements from these sources into your workflow.
Projects are limited to 10,000 files by default, though this can be adjusted if needed. To optimize indexing performance, you can use `.cursorignore` to exclude unnecessary files from the indexing process.
Currently, the simplest method is to place related repositories in the same directory and launch Cursor from there. We're actively developing improved support for managing multiple project folders.
Cursor is frequently updated with new features and improvements. You can find the latest changes and updates in our changelog at [cursor.com/changelog](https://cursor.com/changelog). We regularly release updates to enhance your experience and add new capabilities.
We roll out new releases gradually over multiple days to ensure stability. If you haven't received an update yet, you can expect it to show up soon. You can also manually check for updates by opening the Command Palette (Cmd/Ctrl + Shift + P) and typing "Attempt Update".
You can delete your account and all associated data by going to your [Dashboard](https://cursor.com/settings) and clicking the "Delete Account" button
**Additional resources**
* [Common Issues](/troubleshooting/common-issues) - Solutions to frequently encountered problems
* [Keyboard Shortcuts](/kbd) - Complete list of keybindings and shortcuts
# Installation
Source: https://docs.cursor.com/get-started/installation
Learn how to install, set up, and use Cursor with AI features like Chat, Tab, and Composer
## Installation
1. Visit [cursor.com](https://cursor.com) and click the "Download" button
The installer for your operating system will automatically download
2. Run the installer and wait for installation to complete
3. Launch Cursor via the Desktop shortcut or from the Applications menu
## Setting up
On your first launch, you'll be prompted to configure a few settings to ensure you get up and running quickly!
* **Keyboard shortcuts** - If you are coming from a different editor, you can choose the default shortcuts you want to start with, so they are as familiar as possible.
* **Language** - If you want the AI to talk to you in a different language, you can enter the name of the language you want to use. This can be configured further in the [Rules for AI](/context/rules-for-ai).
* **Codebase Indexing** - Cursor indexes your codebase locally to provide better AI suggestions. Learn more in [Codebase Indexing](/context/codebase-indexing).
* **CLI Shortcuts** - You can choose to install `cursor` and `code` commands to launch Cursor from the terminal
After configuring these settings, you'll be prompted to import your VS Code settings. If you accept, this will import your extensions, themes, user settings, and keyboard shortcuts into Cursor, so you can get started right away.
Next, you'll be asked about your data preference. Read more about them on our [privacy page](/account/privacy)
If you ever need, you can trigger this view by launching cursor with the terminal like this
```sh
cursor --user-data-dir=/some/new/path
```
## Logging In
1. Once you click "Sign Up" or "Login", you'll be prompted to setup an account.
You can choose to use your email, or sign up with Google or GitHub.
2. Once signed in, you'll be sent back to Cursor and you'll be ready to start coding!
If you're using Cursor for the first time, you'll get a 14-day free trial of
Cursor Pro as soon as you sign up. Learn more about Cursor Pro on our
[website](https://cursor.com/features).
## Migrating from other editors
* [VS Code](/get-started/migrate-from-vs-code) for importing your settings, extensions, themes and keyboard shortcuts
We'll be adding more migration guides for other editors soon
## Next steps
Once you're set up, you can start exploring Cursor's AI-powered features:
* **Tab**: Press `Tab` for intelligent code completions
* **CMD-K**: Use `Cmd/Ctrl + K` for inline code edits
* **Chat**: Access AI assistance through the chat panel
* **Composer**: Use the Composer for larger code changes
For more details on these features, check out their dedicated sections in the documentation.
## Additional settings
Cursor is designed to be flexible and customizable, so you can configure it to your liking.
You can access all of your settings by:
### Cursor settings
* Access via gear icon, `Cmd/Ctrl + Shift + J`, or Command Palette > `Cursor Settings`
* Configure AI features and Cursor-specific preferences
### Editor settings
* Access via Command Palette (`Cmd/Ctrl + Shift + P`) > `"Preferences: Open Settings (UI)"`
* Adjust editor behavior and appearance
# Introduction
Source: https://docs.cursor.com/get-started/introduction
Learn how to use Cursor's core features: Tab completion, Chat for code queries, and Agent for assistance
## Overview
Cursor is a powerful AI-first code editor that enhances your development workflow. After [installation](/get-started/installation), you'll have access to three core features that work together seamlessly to make you more productive:
* **AI-powered code completion** that understands your codebase
* **Natural language chat** for exploring and understanding code
* **Intelligent agent** for handling complex development tasks
Each feature builds on top of Cursor's deep understanding of your code through our advanced context system. Let's explore how to use each one effectively.
### Tab
Tab completion in Cursor is powered by advanced AI models that understand your code context. As you type, you'll receive intelligent suggestions that:
* Complete your current line of code
* Suggest entire function implementations
* Help with common patterns and boilerplate
* Adapt to your coding style over time
Learn more about [Tab features](/tab/overview) or see how it [compares to GitHub Copilot](/tab/from-gh-copilot).
### Chat
Chat is your intelligent coding companion that helps you understand and work with your codebase:
* Ask questions about specific code sections
* Get explanations of complex functions
* Find code patterns and examples
* Debug issues with contextual awareness
* Generate code snippets based on your requirements
Explore [Chat features](/chat/overview) or learn how to [customize your experience](/chat/customize).
### Agent
Agent is your AI-powered coding partner that helps you tackle larger tasks:
* Make codebase-wide changes and refactoring
* Implement new features from requirements
* Debug complex issues across multiple files
* Generate tests and documentation
* Maintain consistency across your entire project
Dive deeper into [Agent capabilities](/agent) or try the [Composer](/composer) for complex tasks.
### Context
Context is the foundation that powers all of Cursor's AI features. Here's how it works:
* When you open a codebase, we automatically [index your code](/context/codebase-indexing) to make it available as context
* Use [@-symbols](/context/@-symbols/basic) to precisely control what context you provide:
* [@files](/context/@-symbols/@-files) and [@folders](/context/@-symbols/@-folders) for specific paths
* [@web](/context/@-symbols/@-web) for external documentation
* [@git](/context/@-symbols/@-git) for version control context
* Configure [rules for AI](/context/rules-for-ai) to customize behavior
* Set up [MCP](/context/model-context-protocol) for external context providers
## Models
You can see all the models we support and their pricing on the [models page](/settings/models). Configure your [API keys](/settings/api-keys) and [preferences](/settings/preferences) in Settings.
## Usage
It's highly recommended to read about [usage](/account/usage) and [plans](/account/plans) to understand how Cursor pricing works. Check out our [pricing page](/account/pricing) for more details about plans and features.
Need help? Visit our [troubleshooting guide](/troubleshooting/troubleshooting-guide) or join our [community forum](/resources/forum).
# Migrate from VS Code
Source: https://docs.cursor.com/get-started/migrate-from-vs-code
VS Code-based editor with AI features, supporting extension imports and custom configurations
Cursor is a fork of VS Code. This allows us to focus on making the best way to code with AI, while offering a familiar text editing experience.
## Import Extensions, Themes, Settings, and Keybindings
You can import your VS Code configuration into Cursor with one-click. Navigate to `Cursor Settings` > `General` > `Account`.
## Staying Up to Date
We periodically rebase Cursor onto the latest version of VS Code.
## Why Not an Extension?
As a standalone application, Cursor has more control over the UI of the editor, enabling greater AI integration. Some of our features, like Cursor Tab and CMD-K, are not possible as plugins to existing coding environments.
## Settings
You can open Cursor specific settings pane by clicking on the gear button top-right, by pressing `Ctrl/⌘ + Shift + J`, or with `Ctrl/⌘ + Shift + P` and typing `Cursor Settings`.
You can open VS Code specific settings with `Ctrl/⌘ + Shift + P`, and then typing `VS Code Settings`.
## Why is the Activity Bar in Cursor horizontal?
The activity bar is horizontal by default to save room for chat. If you prefer the normal vertical activity bar you can go to the VS Code settings and set `workbench.activityBar.orientation` to `vertical`, and restart Cursor.
# Welcome to Cursor
Source: https://docs.cursor.com/get-started/welcome
AI-powered IDE with Chat, Tab, and Agent for intelligent code development
Cursor is a new, intelligent IDE, empowered by seamless integrations with AI.
Built upon VSCode, Cursor is quick to learn, but can make you extraordinarily productive.
## Get started
If you're new to Cursor, you can get started using the guides below.
Get started with Cursor in minutes, by downloading and installing for your
platform.
Coming from another editor? Use our migration guides to get started
quickly.
## Editor
Cursor has a number of core features that will seamlessly integrate with your workflow.
Use the links below to learn more about what Cursor can do.
Smart code completion that learns from you! Make multi-line edits, fix
errors you might have missed, and predict your next action.
Your AI pair programmer for complex code changes. Make large-scale edits
with precise context control and automatic fixes.
Quick inline code editing and generation. Perfect for making precise
changes without breaking your flow.
Context-aware AI assistant that understands your codebase. Get answers and
apply code changes directly in your editor.
## Where did Cursor come from?
Code is fundamentally text, and our tools for writing it have evolved from simple text editors into increasingly intelligent development environments.
Initially, we had features like syntax highlighting, to make code more readable. Then, we had features like autocomplete, to make code more efficient.
These have been the standard for a long time, but with Cursor, we're re-inventing how you work with code.
## How does it work?
Cursor provides the user with a few fundamental features that are only made possible by the development of LLMs (Large Language Models).
## How do I get started?
You can download Cursor from the [Cursor website](https://www.cursor.com) for your platform of choice. Being based on VS Code, it's extremely easy to get started, and all the AI features are opt-in.
You can also have Cursor import all your VS Code extensions and settings in one-click. To help you try Cursor, we have a 14-day free trial our of Pro plan, with no credit card required!
# Keyboard Shortcuts
Source: https://docs.cursor.com/kbd
A comprehensive guide to Cursor keyboard shortcuts for Chat, Composer, Tab and Agent
A high level overview of the keyboard shortcuts and keybindings in Cursor. You can see all keyboard shortcuts by pressing `Cmd + R` then `Cmd + S`.
Reference the [Key Bindings for VS Code](https://code.visualstudio.com/docs/getstarted/keybindings) as it serves as a good baseline for Cursor's keybindings.
All `Cmd` keys can be replaced with `Ctrl` on Windows.
## General
| Shortcut | Action |
| ----------------- | ---------------------------- |
| `Cmd + I` | Open Composer |
| `Cmd + L` | Open Chat |
| `Cmd + .` | Toggle Agent in Composer |
| `Cmd + /` | Toggle between AI models |
| `Cmd + Alt + L` | Open Chat & Composer history |
| `Cmd + Shift + J` | Open Cursor settings |
| `Cmd + Shift + P` | Open command palette |
## Chat
| Shortcut | Action |
| ------------------------------ | ---------------------------- |
| `Cmd + Enter` | Submit with codebase |
| `Enter` | Submit |
| `↑` | Select previous message |
| `Select code, Cmd + L` | Add selected code as context |
| `Select code, Cmd + Shift + L` | Add selected code as context |
## Composer
| Shortcut | Action |
| ----------------- | ------------------------- |
| `Cmd + Backspace` | Cancel generation |
| `Cmd + Enter` | Accept all changes |
| `Cmd + Backspace` | Reject all changes |
| `Tab` | Cycle to next message |
| `Shift + Tab` | Cycle to previous message |
| `Cmd + Alt + /` | Open model toggle |
| `Cmd + N` | Create new composer |
| `Cmd + R` | Create new composer |
| `Cmd + Shift + K` | Open composer as bar |
| `Cmd + [` | Previous composer |
| `Cmd + ]` | Next composer |
| `Cmd + W` | Close composer |
| `↑` | Select previous message |
## Cmd+K
| Shortcut | Action |
| ----------------- | ------------------ |
| `Cmd + K` | Open |
| `Cmd + Shift + K` | Toggle input focus |
| `Enter` | Submit |
| `Option + Enter` | Ask quick question |
## Code Selection & Context
| Shortcut | Action |
| --------------------------------------- | ------------------------------------ |
| `@` | [@-symbols](/context/@-symbols/) |
| `#` | Files |
| `Cmd + Shift + L` | Add selection to Chat |
| `Cmd + Shift + K` | Add selection to Edit |
| `Cmd + L` | Add selection to new chat |
| `Cmd + M` | Toggle file reading strategies |
| `Cmd + →` | Accept next word of suggestion |
| `Cmd + Enter` | Search codebase in chat |
| `Select code, Cmd + C, Cmd + V` | Add copied reference code as context |
| `Select code, Cmd + C, Cmd + Shift + V` | Add copied code as text context |
## Tab
| Shortcut | Action |
| --------- | ----------------- |
| `Tab` | Accept suggestion |
| `Cmd + →` | Accept next word |
## Terminal
| Shortcut | Action |
| ------------- | ------------------------ |
| `Cmd + K` | Open terminal prompt bar |
| `Cmd + Enter` | Run generated command |
| `Esc` | Accept command |
# AI Commit Message
Source: https://docs.cursor.com/more/ai-commit-message
Learn how to generate Git commit messages automatically in Cursor using the sparkle icon or shortcuts
Cursor can help you generate meaningful commit messages for your changes with just a click. Here's how to use this feature:
1. Stage the files you want to commit
2. Open the Git tab in the sidebar
3. Look for the sparkle (✨) icon next to the commit message input field
4. Click the sparkle icon to generate a commit message based on your staged changes
The generated commit message will be based on the changes in your staged files and your repository's git history. This means Cursor will analyze both your current changes and previous commit messages to generate a contextually appropriate message. Cursor learns from your commit history, which means if you use conventions like [Conventional Commits](https://www.conventionalcommits.org/), the generated messages will follow the same pattern.
## Shortcut
You can bind the generate commit message feature to a keyboard shortcut.
1. Go to Keyboard Shortcuts `⌘R ⌘S` or `⌘⇧P` and search for "Open Keyboard Shortcuts (JSON)"
2. Add the following to the file to bind to `⌘M`:
```json
{
"key": "cmd+m",
"command": "cursor.generateGitCommitMessage"
}
```
3. Save the file and you're done!
Currently, there isn't a way to customize or provide specific instructions for
how commit messages should be generated. Cursor will automatically adapt to
your existing commit message style.
# Forum
Source: https://docs.cursor.com/resources/forum
Join Cursor's community forum to discuss and share experiences - requires separate forum account
Cursor has a dedicated forum where you can engage with other users, share your experiences, ask questions, and participate in discussions about Cursor.
Currently, the forum requires a separate login from your main Cursor account.
We are working on unifying the authentication systems.
## Getting Started
To participate in the forum:
1. Visit the [Cursor Forum](https://forum.cursor.com)
2. Click "Sign Up" to create a new forum account
3. Create your credentials (separate from your main Cursor login)
4. Start engaging with the community!
We appreciate your understanding as we work to implement a unified login system for all Cursor services.
# Custom API Keys
Source: https://docs.cursor.com/settings/api-keys
Learn how to use your own API keys in Cursor for OpenAI, Anthropic, Google, and Azure LLM providers
Cursor lets you input your own API keys for various LLM providers to send as many AI messages as you want at your own cost. When a Customer API key is used, we will use that when calling the LLM providers.
To use your own API key, go to `Cursor Settings` > `Models` and enter your API keys. Then, click on the "Verify" button. Once your key is validated, your API key will be enabled.
Some Cursor features (like Tab Completion, Apply from Chat, and Composer)
require specialized models and won't work with custom API keys. Custom API
keys only work for features that use standard models from providers like
OpenAI, Anthropic, and Google.
## OpenAI API Keys
You can get your own API key from the [OpenAI platform](https://platform.openai.com/account/api-keys).
OpenAI's reasoning models (o1, o1-mini, o3-mini) require special configuration and are not currently supported with custom API keys.
## Anthropic API Keys
Similar to OpenAI, you can also set your own Anthropic API key so that you will be using claude-based models at your own cost.
## Google API Keys
For Google API keys, you can set your own API key so that you will be using Google models such as `gemini-1.5-flash-500k` at your own cost.
## Azure Integration
Finally, you can also set your own Azure API key so that you will be using Azure OpenAI models at your own cost.
## FAQ
### Will my API key be stored or leave my device?
Your API key will not be stored, but it will be sent up to our server with every request. All requests are routed through our backend where we do the final prompt building.
### What custom LLM providers are supported?
Cursor only supports API providers that are compatible with the OpenAI API format (like OpenRouter). We do not provide support for custom local LLM setups or other API formats. If you're having issues with a custom API setup that isn't from our supported providers, we unfortunately cannot provide technical support.
# Models
Source: https://docs.cursor.com/settings/models
Switch between AI models in Cursor using Chat, Composer, Tab, or Agent with different pricing tiers
With Composer, ⌘ K, and Terminal Ctrl/⌘ K, you can easily switch between different models of your choice.
## Available models
Premium models count against your monthly request quota based on your
subscription plan. Once you exceed your quota, additional requests can be
purchased by enabling usage based pricing.
Pro and Business plans get 500 requests/month included, and can be extended by enabling usage based pricing.
| Model | Provider | Premium | Agent | Pricing | Note |
| :--------------------------------------------------------------------------------------- | :-------- | :-----: | :---: | :------ | :------------------------------------ |
| `cursor-small` | Cursor | | | Free | |
| [`claude-3.5-sonnet`](https://www.anthropic.com/claude/sonnet) | Anthropic | ✓ | ✓ | \$0.04 | |
| [`claude-3.5-haiku`](https://www.anthropic.com/claude/haiku) | Anthropic | ✓ | | \$0.01 | Counts as 1/3 fast request |
| [`claude-3-opus`](https://www.anthropic.com/news/claude-3-family) | Anthropic | ✓ | | \$0.10 | 10 requests/day included on paid plan |
| [`gpt-4o-mini`](https://openai.com/gpt-4o-mini) | OpenAI | ✓ | | | Free plan gets 500 requests/day |
| [`gpt-4o`](https://openai.com/index/hello-gpt-4o/) | OpenAI | ✓ | ✓ | \$0.04 | |
| [`o1`](https://openai.com/index/learning-to-reason-with-llms/) | OpenAI | | | \$0.40 | |
| [`o1-mini`](https://openai.com/index/openai-o1-mini-advancing-cost-efficient-reasoning/) | OpenAI | | | \$0.10 | 10 requests/day included on paid plan |
| [`o3-mini`](https://openai.com/index/openai-o3-mini/) | OpenAI | ✓ | ✓ | \$0.01 | Counts as 1/3 fast request |
| [`deepseek-v3`](https://www.deepseek.com/) | Fireworks | | Soon | Free | |
| [`deepseek-r1`](https://www.deepseek.com/) | Fireworks | ✓ | Soon | \$0.04 | |
You can add additional models under `Cursor Settings` > `Models`. All models are hosted on US-based infrastructure.
## Model dropdown
Underneath the AI input box, you will see a dropdown that allows you to select the model you want to use. The following models are available:
## Context windows
In Chat and Composer, we use a 40,000 token context window by default. For Cmd-K, we limit to around 10,000 tokens to balance TTFT and quality. Agent starts at 60,000 tokens and supports up to 120,000 tokens. For longer conversations, we automatically summarize the context to preserve token space. Note that these threshold are changed from time to time to optimize the experience.
# Preferences
Source: https://docs.cursor.com/settings/preferences
Learn how to customize Chat, Composer, Terminal, and Editor features in Cursor's settings menu
You can set preferences for certain features from Cursor Settings
Preferences are stored locally and are not synchronized across different machines
## Chat & Composer
### Agent Stickiness
If enabled, your selection between normal and Agent mode will persist across new Composer conversations.
### Auto-Scroll to Bottom
Automatically scrolls to the bottom of the Composer pane when a new message is generated.
#### Auto-Apply to Files Outside Context
Allows Composer to automatically apply changes to files outside your current context.
#### Collapse Input Box Pills in Pane or Editor
Collapses pills in the Composer pane or the editor input box to save space.
#### Render Pills Instead of Blocks
Collapses Composer code blocks into pills instead of rendering them as code blocks.
#### Iterate on Lints
If there are linter errors, Composer will try to fix them iteratively.
### Codebase Indexing
#### Index New Files by Default
When enabled, new files will be indexed automatically by default. If disabled, you can still index your folders by pressing the "Compute Index" button.
Indexes are auto-generated only for folders with fewer than 10,000 files.
#### Git Graph Relationships
When enabled, Cursor will index your git history to understand relationships between files.
Code and commit messages are stored locally, while metadata about commits (SHA’s, number of changes, and obfuscated filenames) is stored in the cloud.
### Editor
#### Chat/Edit Tooltip
If enabled, shows a chat/edit tooltip near highlighted code in your editor.
#### Auto Parse Links
If enabled, Cursor automatically parses links and adds them to the context.
#### Auto-Select for `Ctrl/Cmd + K`
If enabled, Cursor automatically selects regions for inline code editing.
#### Themed Diffs
If enabled, Cursor uses themed background colors for inline diffs in your editor.
### Terminal
#### Show Terminal Hover Hint
If enabled, shows a hover hint in the terminal with the command to 'Add to Chat' or 'Debug with AI'.
#### Use Preview Box
If enabled, Cursor uses a preview box in the terminal to show the output of `Ctrl/Cmd + K`. If disabled, responses stream directly into the terminal.
# Advanced Features
Source: https://docs.cursor.com/tab/advanced-features
Learn to navigate code efficiently using Tab in peek views, prediction, and partial accepts
## Tab in Peek
You can also use Cursor Tab in the "Go to Definition" or "Go to Type Definition" peek views. This is useful, for example, when adding a new argument to a function call.
We especially enjoy using this in vim in conjunction with `gd` to, for example, modify a function definition, then fix all of its usages in one go.
## Cursor Prediction
Cursor can also predict where you will go to after an accepted edit.
If available, you will be able to press tab to go to the next location, allowing you to tab-tab-tab through edits.
## Partial Accepts
You can accept the next word of a suggestion by pressing `Ctrl/⌘` and the right arrow (or by setting `editor.action.inlineSuggest.acceptNextWord` to your preferred keybinding).
To enable partial accepts, navigate to `Cursor Settings` > `Features` > `Cursor Tab`.
# Auto-import
Source: https://docs.cursor.com/tab/auto-import
Auto-import feature in Tab helps add module imports automatically in TypeScript and Python projects
## Overview
In TypeScript and Python (beta) project, Tab can automatically import modules and functions from elsewhere in your project, without you having to manually type the import statement.
Just start using the method you want from an existing file, and Tab will automatically suggest the import statement for you. If you accept, the import statement will be added to your file without pulling you away from the code you are writing.
## Troubleshooting
If you are having issues with auto-import, please confirm you have the necessary extensions (e.g. a language server) for your project language, as this is required for auto-import to work.
You can confirm if this is working, by moving your cursor to a function or method that is not yet imported, and hit ⌘ + . or Ctrl + . to see if the import is suggested in the Quick Fix suggestions - if not, then the language server is not working.
# Tab vs GitHub Copilot
Source: https://docs.cursor.com/tab/from-gh-copilot
Learn how Cursor's code editing capabilities surpass GitHub Copilot with multi-character & instructional edits
## Tab Improvements
The biggest difference is the way Cursor and GitHub Copilot complete code.
GitHub Copilot can insert text at your cursor position. It cannot edit the code around your cursor or remove text.
Cursor can insert text at your cursor, and much more:
* Multi-character edits
* Instruction-based edits
Further, Cursor has a history of your recent changes in the context window, so it knows what you are trying to do next.
## Migrate from GitHub Copilot
Since Cursor comes by default with GitHub Copilot, you might have GitHub Copilot and Cursor installed at the same time. We recommend turning off GitHub Copilot when you want to use Cursor.
By default, Cursor takes precedence over GitHub Copilot. If you want to use GitHub Copilot, you can [disable Cursor](/tab/overview#copilot-settings) in the settings.
# Overview
Source: https://docs.cursor.com/tab/overview
AI-powered code autocomplete that suggests edits and multi-line changes based on your recent work
Cursor Tab is our native autocomplete feature. It's a more powerful Copilot that suggests entire diffs with especially good memory.
Powered by a custom model, Cursor Tab can:
* Suggest edits around your cursor, not just insertions of additional code.
* Modify multiple lines at once.
* Make suggestions based on your recent changes and linter errors.
Free users receive 2000 suggestions at no cost. Pro and Business plans receive unlimited suggestions.
## UI
When Cursor is only adding additional text, completions will appear as grey text. If a suggestion modifies existing code,
it will appear as a diff popup to the right of your current line.
You can accept a suggestion by pressing `Tab`, or reject it by pressing `Esc`. To partially accept a suggestion word-by-word, press `Ctrl/⌘ →`.
To reject a suggestion, just keep typing, or use `Escape` to cancel/hide the suggestion.
Every keystroke or cursor movement, Cursor will attempt to make a suggestion based on your recent changes. However, Cursor will not always show a suggestion; sometimes the model has predicted that there's no change to be made.
Cursor can make changes from one line above to two lines below your current line.
## Toggling
To turn the feature on or off, hover over "Cursor Tab" icon on the status bar in the bottom right of the application.
## FAQ
### Tab gets in the way when writing comments, what can I do?
You can disable Cursor Tab for comments by going to `Cursor Settings` > `Tab Completion` and unchecking "Trigger in comments".
# Common Issues
Source: https://docs.cursor.com/troubleshooting/common-issues
Guide for troubleshooting common Cursor app issues including updates, login, and connectivity problems
## Network Issues
If you're experiencing connectivity issues with Cursor, here are some steps to troubleshoot:
Common symptoms of network issues include:
* Codebase indexing failing with errors
* Agent showing connection errors
* Tab autocomplete not working
* Chat or other AI features failing to respond
Here are the steps to troubleshoot:
1. Check your internet connection
2. Verify if you're behind a corporate proxy or VPN
3. Test if HTTP/2 is accessible by running:
```bash
curl -I --http2 -v https://api2.cursor.sh
```
If you see the following response, it indicates HTTP/2 is not properly negotiated:
```
* ALPN: server did not agree on a protocol. Uses default.
* using HTTP/1.x
```
#### ZScaler
If you're using ZScaler and experiencing connectivity issues, here are your options:
1. Configure the ZScaler proxy to properly support HTTP/2 ALPN negotiation
2. Allowlist the cursor.sh domain to bypass the ZScaler inspection
The following domains need to be accessible:
* `api2.cursor.sh`: Used for most API requests
* `api3.cursor.sh`: Used for Cursor Tab requests (HTTP/2 only)
* `repo42.cursor.sh`: Used for codebase indexing (HTTP/2 only)
* `api4.cursor.sh`, `us-asia.gcpp.cursor.sh`, `us-eu.gcpp.cursor.sh`, `us-only.gcpp.cursor.sh`: Used for Cursor Tab requests depending on your location (HTTP/2 only)
* `marketplace.cursorapi.com`, `cursor-cdn.com`: Used for downloading extensions from the extension marketplace
* `download.todesktop.com`: Used for checking for and downloading updates
To verify if ZScaler is causing the issue, try temporarily disconnecting from ZScaler and test if Cursor's functionality is restored.
## Resource Usage Issues
If you're experiencing high CPU or RAM usage in Cursor, here are steps to diagnose and resolve the issue:
1. Check enabled extensions
* Some extensions can significantly impact performance
* Disable extensions one by one to identify problematic ones
* Consider removing unused extensions
2. Use Process Explorer
* Open the Command Palette (`Cmd/Ctrl + Shift + P`)
* Type "Developer: Open Process Explorer"
* Monitor which processes are consuming resources
* Look for any processes using excessive CPU or memory
3. Monitor system resources
* Check if the issue is Cursor-specific or system-wide
* Consider closing other resource-intensive applications
* Ensure your system meets the minimum requirements
4. Test with minimal extensions
* Start Cursor with extensions disabled
* If performance improves, gradually re-enable extensions
* This helps identify which extensions may be causing issues
When reporting resource usage issues, screenshots of the Process Explorer and your system's resource monitor can be extremely helpful in diagnosing the problem.
## Other
#### I see an update on the changelog but Cursor won't update.
If the update is very new, it might not have rolled out to you yet. We do staged rollouts, which means we release new updates to a few randomly selected users first before releasing them to everyone. Expect to get the update in a couple days!
#### I have issues with my GitHub login in Cursor / How do I log out of GitHub in Cursor?
You can try using the `Sign Out of GitHub` command from the command palette `Ctrl/⌘ + Shift + P`.
#### I can't use GitHub Codespaces.
Unfortunately, we don't support GitHub Codespaces yet.
#### I have errors connecting to Remote SSH.
Currently, we don't support SSHing into Mac or Windows machines. If you're not using a Mac or Windows machine, please report your issue to us in the [forum](https://forum.cursor.com/). It would be helpful to include some logs for better assistance.
#### SSH Connection Problems on Windows
If you encounter the error "SSH is only supported in Microsoft versions of VS Code", follow these steps:
1. Uninstall the current Remote-SSH extension:
* Open the Extensions view (`Ctrl + Shift + X`)
* Search for "Remote-SSH"
* Click on the gear icon and select "Uninstall"
2. Install version 0.113 of Remote-SSH:
* Go to the Cursor marketplace
* Search for "Remote-SSH"
* Find version 0.113 and install it
3. After installation:
* Close all VS Code instances that have active SSH connections
* Restart Cursor completely
* Try connecting via SSH again
If you still experience issues, make sure your SSH configuration is correct and that you have the necessary SSH keys set up properly.
#### Cursor Tab and Cmd K do not work behind my corporate proxy.
Cursor Tab and Cmd K use HTTP/2 by default, which allows us to use less resources with lower latency. Some corporate proxies (e.g. Zscaler in certain configurations) block HTTP/2. To fix this, you can set `"cursor.general.disableHttp2": true` in the settings (`Cmd/Ctrl + ,` and then search for `http2`).
#### I just subscribed to Pro but I'm still on the free plan in the app.
Try logging out and logging back in from the Cursor Settings
#### When will my usage reset again?
If you're subscribed to Pro you can click on `Manage Subscription` from the [Dashboard](https://cursor.com/settings) and your plan renewal date will be displayed at the top.
If you're a free user you can check when you got the first email from us in your inbox. Your usage will reset every month from that date.
#### My Chat/Composer history disappeared after an update
If you notice that your Chat or Composer history has been cleared following an update, this is likely due to low disk space on your system. Cursor may need to clear historical data during updates when disk space is limited. To prevent this from happening:
1. Ensure you have sufficient free disk space before updating
2. Regularly clean up unnecessary files on your system
3. Consider backing up important conversations before updating
#### How do I uninstall Cursor?
You can follow [this guide](https://code.visualstudio.com/docs/setup/uninstall) to uninstall Cursor. Replace every occurrence of "VS Code" or "Code" with "Cursor", and ".vscode" with ".cursor".
#### How do I delete my account?
You can delete your account by clicking on the `Delete Account` button in the [Dashboard](https://cursor.com/settings). Note that this will delete your account and all data associated with it.
#### How do I open Cursor from the command line?
You can open Cursor from the command line by running `cursor` in your terminal. If you're missing the `cursor` command, you can
1. Open the command palette `⌘⇧P`
2. Type `install command`
3. Select `Install 'cursor' command` (and optionally the `code` command too which will override VS Code's `code` command)
#### Unable to Sign In to Cursor
If you click Sign In on the General tab of Cursor's Settings tab but are redirected to cursor.com and then return to Cursor still seeing the Sign In button, try disabling your firewall or antivirus software, which may be blocking the sign-in process.
# Getting a Request ID
Source: https://docs.cursor.com/troubleshooting/request-reporting
Learn how to find and share request IDs in Cursor for better technical support and issue reporting
When the Cursor team are investigating a technical issue, sometimes, we may ask you to provide us with a "request ID".
## What is a request ID?
A request ID is a unique identifier that is generated when you submit a request to Cursor. It is a string of characters that is used to identify the request in our internal systems.
It usually follows a randomized format, such as: `8f2a5b91-4d3e-47c6-9f12-5e8d94ca7d23`.
## How do I find a request ID?
Request IDs are highly limited when Privacy Mode is enabled, so we recommend disabling Privacy Mode when reporting an issue.
As a reminder, users on a business plan have Privacy Mode enabled by default, by their organization's admin.
You can retrieve a request ID from within Cursor, by running the `Report AI Action` command.
You you can do this by:
1. Opening the command palette `⌘⇧P`
2. Typing `Report AI Action`
3. Selecting the `Report AI Action` option
This will open a new popup, listing your most recent AI actions across Chat, Composer, CMD+K and Tab.
Select the action you want to report, by matching the time and feature the action was used in. Once you select the action, you have the option to copy the request ID to your clipboard. With it copied, you can send it back to us to look into!
# Troubleshooting Guide
Source: https://docs.cursor.com/troubleshooting/troubleshooting-guide
Technical guide for gathering logs, errors and system info when reporting Cursor app issues
Capture a screenshot of the issue, making sure to redact any sensitive
information.
Document the exact steps needed to reproduce the issue.
Retrieve system information from: `Cursor` > `Help` > `About`
Note if you're using a VPN or proxy like Zscaler.
Check developer tools console errors: 1. Open developer tools via: `Cursor` >
`Help` > `Toggle Developer Tools` 2. Click `Console` 3. Look for any related
errors
Access logs through one of these methods:
On Windows, find logs at:
```txt
C:\Users\\AppData\Roaming\Cursor\logs
```
Or open logs folder via:
* `Ctrl` + `Shift` + `P` (command palette)
* Type and select `Developer: Open Logs Folder`
Alternatively, view logs in:
`Cursor` > `Terminal` > `Output` > select `Window` or other Cursor options