# Custom API Keys
Learn how to use your own API keys for various LLM providers in Cursor
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` > `OpenAI API Key` and enter your API key. Then, click on the "Verify" button. Once your key is validated, your OpenAI 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).
### 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.
### 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, because that's where we do the final prompt building.
# Keyboard Shortcuts
Learn Cursor with these keyboard shortcuts and keybindings
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 |
# Models
Learn about the different AI models available in Cursor and how to use them
With Cursor Chat, Ctrl/⌘ K, and Terminal Ctrl/⌘ K, you can easily switch between different models of your choice.
### Model Dropdown
Underneath the AI input box, you will see a dropdown that allows you to select the model you want to use. By default, Cursor has these models ready to use:
* [`GPT-4o`](https://openai.com/index/hello-gpt-4o/)
* [`GPT-4`](https://openai.com/index/gpt-4/)
* [`Claude 3.5 Sonnet`](https://www.anthropic.com/news/claude-3-5-sonnet)
* `cursor-small`
* `cursor-small` is Cursor's custom model that isn't as smart as `GPT-4`, but is faster and users have unlimited access to it.
You can add additional models under `Cursor Settings` > `Models` > `Model Names`.
### What context window is used for model X?
In chat, we limit to around 20,000 tokens at the moment (or less if the model does not support that much context). For cmd-K, we limit to around 10,000 tokens, to balance TTFT and quality. Long-context chat uses the model's maximum context window.
# Billing FAQ
Everything you need to know about managing your Cursor subscription and billing
### 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**
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**
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).
### How do trials work?
Pro trials 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.
### What is usage-based pricing?
You can opt in to usage-based pricing for requests beyond your plan's included quota through your [settings page](https://cursor.com/settings). Premium model requests cost $0.04 each and are billed in blocks of 500 requests ($20). You can set a monthly spending limit to control costs, and you'll never be charged more than your configured limit.
### 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.
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 get you sorted out.
This is our self-serve refund policy:
**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
# Apply
Learn how to apply code suggestions from Cursor Chat directly to your codebase
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
Learn how to use Cursor Chat with your codebase for accurate code-aware responses
### Default Codebase Chat
If a codebase isn't [indexed](/context/codebase-indexing), Cursor 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), Cursor Chat can accurately generate responses based on your codebase.
By pressing `Ctrl/⌘ + Enter` after typing a message, Cursor 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
Learn how to customize Cursor Chat with different models and settings
### Choose an AI Model
Pick your preferred AI model through the [model toggle](/advanced/models#model-dropdown), and Cursor Chat will use that model to generate responses. You can toggle between models by pressing `Ctrl/⌘ /`.
By default, Cursor Chat uses OpenAI's `GPT-4` for its AI model (specifically, the `gpt-4` label points to our instance of GPT4-Turbo).
The AI model you choose for Chat will be saved for future sessions, so you don't have to change it every time you open Cursor Chat.
### In-Editor
Cursor 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.
Cursor Chat will then behave as a regular editor tab. Pressing `Ctrl/⌘ + L` will bring up the chat tab and focus onto it.
### Settings
You can customize the Cursor Chat under `Cursor Settings` > `Features` > `Chat`.
These settings include:
* Always search the web for answers.
* This will make the AI model browse the web each query for the most up-to-date information.
* Add chat fading animation.
* This adds a smooth animation to the AI messages as they are generated.
* Auto scroll chat.
* This will automatically scroll the chat as the AI generates text when at the bottom of the thread.
* Narrow scrollbar in the chat pane.
* Show chat history when starting a new chat.
# Overview
Learn about Cursor Chat, your AI coding assistant that lives in your editor
Cursor 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. They are built to eliminate the tedious copy-pasting otherwise necessary for working with language models on code.
By default, Cursor 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 on 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, Cursor 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
Learn how to use Cmd K for quick code generation and editing in Cursor
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
Learn how to use Cmd K in Cursor's terminal for AI-powered command generation
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.
# Forum
Join the Cursor community forum to engage with other users, share experiences, and get help
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 actively 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.
# Overview
A developer's guide to Composer
# Welcome to Composer
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.
# Agent
Enable Agent with `⌘.` to get a coding partner that proactively works with your codebase:
* Automatically pull relevant context (try `@Recommended`)
* Run terminal commands
* Create and modify files
* Search code semantically
* Execute file operations
{/*
*/}
Agent can make up to 25 tool calls before stopping. If you need more, let us know at [hi@cursor.com](mailto:hi@cursor.com)!
For now, Agent supports only Claude models.
Each tool operation counts as a separate request toward your quota.
# Normal
Normal mode provides core features for code exploration and generation:
* Search through your codebase and documentation
* Use web search
* Create and write files
* Access expanded `@`-symbol commands
# Working with Context
Type `@` to see context options based on your current work. Navigate with arrow keys, select with Enter, and filter by typing after `@`. Use `Ctrl/⌘ M` to switch file reading methods. `@Recommended` in Agent automatically pulls relevant context.
**`#` File Selection**\
Use `#` followed by a filename to focus on specific files. Combine this with `@` symbols for precise context control.
**Context Pills**\
Pills at the top of your chat show active context. Add or remove pills to adjust what Composer sees. Use `#` to select files, which then appear as pills.
# 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
Every time you generate code, Composer creates a checkpoint. 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
Composer offers two layout modes:
* 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.
# Beta Features
## 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?
Cursor 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.
# @Chat
This feature is currently only for Cmd K.
### `@Chat`
You can add your current chat messages as context by using `@Chat` inside Cmd K.
This is useful for when you have a conversation with the AI that you'd like to be applied to edit or generate code.
# @Code
Learn how to reference specific sections of code in Cursor
### `@Code`
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
Learn how to use advanced codebase search in Cursor Chat
### `@Codebase`
Through `@Codebase`, Cursor 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.
# @Definitions
This feature is currently only for Cmd K.
### `@Definitions`
The `@Definitions` symbol adds all nearby definitions to Cmd K as context.
# @Docs
### `@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
### `@Files`
In AI input boxes such as in Cursor 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.
### 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 Chat or Cmd K to add them as context as well.
# @Folders
Learn how to reference entire folders as context in Cursor Chat
Currently, `@Folders` is only supported in the Cursor Chat.
### `@Folders`
You can also reference entire folders in Cursor as context. `@Folders` is especially
useful for [long context chat](/chat/overview#long-context-chat) where you want to provide a lot of context to the AI.
# @Git
Currently, `@Git` is only supported in the Cursor Chat.
### `@Git`
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.
# Paste Links
### `@https://your-link.com`
In order for Cursor to visit a link before responding, type `@` and then paste in the link.
### Remove Links
By default, we automatically parse links and turn them into `@Links` in Cursor Chat.
If you prefer to have the link as plain text, click on the link and then click `Unlink`.
# @Web
### `@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.
# Basic Usage
Learn how to use @ symbols in Cursor's AI input boxes
In Cursor's AI input boxes, such as in Cmd K, Chat, or Terminal 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.
### Cmd K Keyboard Shortcut
You can use the up/down arrow key to navigate through the list of selected Cmd K @ symbols, `Enter` to expand/collapse the selected context item. For file references, you can use
`Ctrl/⌘ M` to toggle the file reading strategies. Read more about file reading strategies [here](/context/@-symbols/@-files#cmd-k-chunking-strategy).
# Codebase Indexing
Learn how to index your codebase for better AI-powered code understanding
### Index your Codebase
For better and more accurate codebase answers using `@codebase` or `Ctrl/⌘ Enter`, 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.
Your codebase index will automatically synchronize with your latest codebase changes.
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, in addition to your .gitignore settings.
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.
# Ignore Files
The .cursorignore file lets you exclude files and directories from Cursor's codebase indexing
# 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, Cursor Chat and Composer have access to all files in their context, regardless of `.cursorignore` settings.
More info on how we handle AI request 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 have had the same issue and StackOverflow will have a good answer.
One common example: [here is 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).
# Rules for AI
Learn how to customize AI behavior with global and project-specific rules
You can add custom instructions to Cursor by modifying the `Rules for AI` section under `Cursor Settings` > `General` > `Rules for AI`.
This custom instruction will be included for features such as Cursor Chat and Ctrl/⌘ K.
### `.cursorrules`
For project-specific instructions, you can include the instructions in a `.cursorrules` file in the root of your project.
As the same as the "Rules for AI" section, the instructions in the `.cursorrules` file will be included for features such as Cursor Chat and Ctrl/⌘ K.
# Notepads
Learn how to use Notepads to share context between composers and chat
Notepads are currently in beta
# 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
```
# Generate Commit Message
Generate a commit message for your staged files
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 the AI 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. The AI will automatically adapt to your existing commit message style.
# Migrate from VS Code
Learn how to migrate your VS Code setup to Cursor and understand key differences
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.
# Usage
Learn about Cursor's subscription tiers, usage limits, and pricing options
For more pricing info, please visit [Cursor Pricing](https://cursor.com/pricing).
### Subscription Tiers
Cursor offers multiple subscription tiers to fit your needs.
* **Hobby**
* 14 days **Pro trial**
* 50 slow `premium` model uses
* 2000 [completions](/tab/overview) uses
* **Pro**
* 500 fast `premium` model uses per month
* Unlimited slow `premium` model uses
* Unlimited [completions](/tab/overview) completions
* 10 `o1+mini` uses per month
* **Business**
* Usage information is the same as the `Pro` tier
* Enforce privacy mode org-wide
* Centralized team billing
* Admin dashboard with usage stats
* SAML/OIDC SSO
### Premium models
GPT-4, GPT-4o, and Claude 3.5 Sonnet are all counted as `premium` models. Each request to Claude 3.5 Haiku is counted as 1/3 of a `premium` model request.
### Pro Trial
All new users start with a 14-day Pro trial that includes:
* Full access to Pro features
* 150 fast `premium` model requests
After the trial period ends, accounts automatically transition to the Hobby plan unless upgraded to Pro.
### Fast and Slow Requests
By default, Cursor servers try to give all users fast `premium` model requests. However, during peak periods,
users who run out of fast `premium` credits will be moved to a slow pool, which essentially is a queue of users waiting for
a fast `premium` request to become available.
This queue is fair, and Cursor will do everything possible to keep the queue as short as possible.
However, if you need more fast `premium` credits and don't want to wait, you can add more requests on the [settings page](https://cursor.com/settings).
### Purchasing additional requests
We're actively working on the ability to purchase additional fast requests. For now, these are the ways to do it:
#### Fast Requests Packages
Additional fast requests are available in packages of 500 for \$20/month to increase your monthly quota.
For annual plans, packages are billed annually at \$240. For monthly plans, packages are billed monthly at \$20.
Mid-cycle purchases are prorated based on remaining days and billed immediately upon upgrading. For example, purchasing halfway through your billing cycle means paying for half the month.
Note that additional packages on a Pro plan will show up as separate Pro subscriptions in your billing dashboard.
#### Usage-based Pricing
You may opt in to usage-based pricing for requests that go beyond what is included in your plan by visiting your [settings page](https://cursor.com/settings).
Usage-based pricing details:
* Usage-based pricing is per calendar month (not necessarily same as your billing cycle, will be billed roughly on the 2nd-3rd day of the month)
* Available for premium models and other specialized models like o1, Claude 3 Opus
* Premium cost \$0.04 per request and are billed every 500 requests (\$20)
* If you immediately cancel a request or if it errors we do not count it
* You can set a Monthly spending limit to control your maximum usage costs
* You will never be charged more than your configured spending limit per month
* For team accounts, administrators can restrict usage-based pricing settings to admin-only access
### Check Your Usage
You can check your usage on the [Cursor Settings](https://cursor.com/settings) page. You can reach this page inside the Cursor application as well,
under `Cursor Settings` > `General` > `Account`, and press "Manage Subscription" for pro users, or "Manage" for business users.
Cursor usage resets monthly, based on your subscription start date.
# Getting Started
Set up your Cursor Business team with centralized billing and SSO support
### Upgrading to Business
1. Open your [Cursor Settings dashboard](https://cursor.com/settings) where you will see this section:
2. Click `Upgrade to Business` and fill in:
* Team name
* Billing cycle (monthly/yearly)
3. Click `Create Team` and proceed to billing
4. Once billing is complete, you can start inviting team members!
5. For extra security, you can set up SSO or Domain Verification by clicking on the `SSO`
### Current Authentication Options
* Email login (magic link)
* Gmail/Google/GitHub account authentication
* SAML/OIDC SSO support
# Team Roles
Understanding the different roles and permissions in Business
Business plans offers three role types to help you manage your team effectively. Each role has specific permissions and billing implications.
### Member
Members are standard users who can access and use all Business features while contributing to team collaboration.
* Access to all [Business features](https://cursor.com/pricing)
* Can invite team members
* Billed for a user seat
### Admin
Admins have comprehensive control over team management and security settings to ensure smooth team operations.
* Full team management capabilities:
* Add/remove team members
* Modify team roles
* Control team-wide settings
* Usage and security controls:
* Enable/disable usage-based features
* Configure privacy settings
* Set organization-wide policies
* Usage-based pricing controls:
* Enable/disable usage-based pricing
* Set organization-wide spending caps
* Access to admin dashboard
* Billed for a user seat
### Unpaid Admin
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
### Role Comparison
This table provides a detailed breakdown of capabilities across all role types in Business.
| Capability | Member | Admin | Unpaid Admin |
| ----------------------- | :----: | :---: | :----------: |
| Use Cursor Features | ✓ | ✓ | |
| Invite Team Members | ✓ | ✓ | ✓ |
| Add/Remove Team Members | | ✓ | ✓ |
| Modify User Roles | | ✓ | ✓ |
| Access Admin Dashboard | | ✓ | ✓ |
| Configure SSO/Security | | ✓ | ✓ |
| Manage Billing & Subs | | ✓ | ✓ |
| Set Usage Controls | ✓ | ✓ | ✓ |
| Monitor Team Activity | | ✓ | ✓ |
| Requires Paid Seat | ✓ | ✓ | |
# Team Management
Learn how to manage team members and configure team settings
### Adding Team Members
**Email Invitations**
* Click the `Invite Members` button
* Enter email addresses
**Invite links**
* Click the `Invite Members` button
* Copy the `Invite Link`
* Share with team members
Invite links currently do not expire.
### Understanding Billing Impact
When adding new team members:
* Each new member or admin adds a billable seat (see [pricing](https://cursor.com/pricing))
* Billing adjusts automatically
* Changes are prorated for your billing period
* Unpaid admin seats are not counted
When you add 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 (like from Member to 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.
### Team Configuration
#### User Management
* Modify user roles from the team dashboard
* Enable/disable features for specific users
* Monitor user activity and usage
#### Security Settings & SSO
* Configure SSO connections
* Set up domain verification
* Manage access controls
#### SCIM & Provisioning
* SSO configuration blocks other sign-in methods automatically
* Just-in-time (JIT) provisioning available for domain users with SSO
* SCIM provisioning coming soon
#### Usage Controls
Access usage settings to:
* Set spending caps
* Monitor team-wide usage
### Billing
[How do I switch to annual billing?](/billing/billing-faq#can-i-switch-between-monthly-and-annual-billing)
# 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).
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).
# Features
The features section lets you manage which Cursor-specific features you want to use.
### Cursor Tab
Here, you can enable [Cursor Tab](/tab/overview) and its [Advanced Features](/tab/advanced-features) in your editor.
### Chat & Composer
Here, you can configure [Cursor Chat](/chat/overview) and manage settings for Composer in your editor.
##### 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 \[BETA]
If there are linter errors, Composer will try to fix them iteratively.
### Codebase Indexing
Here, you can configure [Codebase Indexing](/codebase-indexing/overview) in your editor.
##### 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.
##### Ignore Files
Add files to [Ignore](/context/ignore-files) during indexing, in addition to your `.gitignore`.\
This is helpful for excluding large files you don’t want to index.
##### 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.
### Docs
Here, you can configure and manage [Docs](/context/@-symbols/@-docs) in your editor.
### Editor
Here, you can configure and manage your overall editor experience.
##### 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.
# Models
The Models section is where you can manage which models are available for use in Cursor Chat, `Ctrl/⌘ K`, and `Terminal Ctrl/⌘ K`. We add the latest models to Cursor as soon as they become available.
### Model Dropdown
Under the AI input box, you’ll see a dropdown that lets you choose which model to use. By default, Cursor provides these [models](/advanced/models).
This is especially useful if you want to use a model offered by a supported provider but don’t see it listed in this settings section. Note that if enabled, you’ll be using Cursor at public LLM API costs, subject to your specific account’s usage limits.
### Supported Providers
We support all major LLM providers, including:
* OpenAI
* Anthropic
* Google
* Azure
# Overview
Cursor Settings lets you configure Cursor to your liking. Access it via `Cursor` > `Settings` > `Cursor Settings`.
### General
Here, you can:
* Import your VS Code settings.
* Write your own [Rules for AI](/context/rules-for-ai).
* Configure editor settings.
* Manage your [privacy](/privacy/privacy) settings.
# Advanced Features
### 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`.
# Migrate from GitHub Copilot
### 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
Learn about Cursor Tab, our powerful AI autocomplete feature
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 get's 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
Find solutions to common problems and frequently asked questions about Cursor
#### 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.
#### 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 Popup](/get-started/glossary#cursor-settings-popup).
#### 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.
#### 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)
# Getting a Request ID
Learn how to find and share request IDs when reporting issues to the Cursor team
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 Private Mode is enabled, so we recommend disabling Private Mode when reporting an issue.
As a reminder, users on a business plan have Private 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!
{/* ## What does a Request ID reveal?
A request ID lets us see the exact request you made to Cursor, including the context that was provided and the response recieved from the AI.
This can be incredibly helpful when investigating an issue, as it allows us to see exactly what the AI was given, both the prompt and the context, as well as the response it gave. With this information, we can better understand where an AI might have gone wrong.
Request IDs are only ever used by the Cursor team for diagnosing issues, and are only ever looked up at the request of a Cursor user. They are not shared with your organization's admins, nor with any 3rd parties. */}
# Troubleshooting Guide
Learn how to gather information and debug issues in Cursor effectively
The following is a list of information that is helpful to retrieve for most troubleshooting scenarios within Cursor:
**01)** Screenshot of issue (redact any sensitive information)
**02)** Steps to reproduce
**03)** System Information from:
`Cursor` > `Help` > `About`
**04)** Are you using a VPN or Zscaler?
**05)** Developer tools console errors
Open developer tools via:
`Cursor` > `Help` > `Toggle Developer Tools`
and then click `Console` and see if there are any related errors.
**06)** Logs
On Windows, you can find logs here:
```txt
C:\Users\\AppData\Roaming\Cursor\logs
```
This is the parent folder of the folder that is opened when doing:
* `Ctrl` + `Shift` + `P` (to open command palette in Cursor)
* Typing and selecting `Developer: Open Logs Folder`
You can also view logs in `Cursor` > `Terminal` > `Output` and then click on the dropdown and select `Window` or one of the other Cursor specific options, such as `Cursor Tab` or `Cursor Indexing & Retrieval`.