Managing Your Cursor Account

Your Cursor account is the key to every cloud feature in the editor: sign-in, your subscription tier, usage limits, and Settings Sync across machines. This guide covers the parts you actually touch day to day, from choosing a sign-in method to changing your email, merging duplicates, understanding what syncs between devices, and deleting an account cleanly.

Sign-In Methods

Cursor offers three sign-in paths. They all resolve to the same account record on the backend, but their recovery and security properties differ in ways that matter later.

Email Magic Link

You enter your email address and Cursor sends a one-time link. Click the link and you are signed in. There is no password involved.

• Fast on a machine you trust
• No dependency on a third-party identity provider
• Recovery depends entirely on continued access to that mailbox

Google

You sign in with your Google account through OAuth. Your Cursor identity is bound to the Google account identifier.

• Strong default security when Google 2FA is enabled
• Convenient if you already live inside Google Workspace
• Migrating to a different Google account later is not straightforward

GitHub

You sign in through GitHub OAuth, which is the most common path for developers.

• Widely used and easy to revoke from your GitHub security settings
• A good fit when your coding identity already lives on GitHub
• Ties your Cursor session to your GitHub 2FA posture

Method	Pros	Cons
Email magic link	No password; works with any mailbox	Fully dependent on mailbox access; the link itself is a credential
Google	Strong 2FA, familiar flow	Hard to migrate away from later
GitHub	Developer-friendly, trivially revocable	Inherits whatever 2FA strength GitHub has

Switching Sign-In Providers

You cannot switch providers inside the app. Moving from GitHub to Google, or from a magic link to GitHub, is a support-assisted migration because it changes the identity that owns your subscription and history. Treat it exactly like an email change: open a ticket, prove ownership of both methods, and expect a fresh sign-in afterward.

If you only want to stop using one method without moving the account, simply sign in with the method you intend to keep. Do not sign up fresh with the new provider, because that creates a duplicate account rather than migrating the existing one, and the subscription stays behind on the old record.

Pick the provider you already harden

If your GitHub account already enforces 2FA, signing in with GitHub means Cursor inherits that protection for free. Choose whichever provider carries the strongest security posture you actually maintain, not the one that is marginally faster to click.

Whichever method you choose, the first sign-in creates the account record. Later sign-ins must use the same method, or you will silently create a second account, which is the root of most "my subscription disappeared" reports.

Where to Find Subscription and Usage

Two surfaces matter: the web dashboard and the in-app account settings. They show overlapping but not identical information.

The Web Dashboard

Open https://cursor.com/dashboard in a browser. The dashboard is the authoritative view for anything billing-related:

• Subscription: your current tier (Free, Pro, Pro+, Business, Enterprise) and the renewal date
• Usage: requests consumed in the current cycle, broken down by model
• Billing: invoices, payment method, and seat count for teams

The usage view is where you see how close you are to your limits. It separates premium model requests from cheaper or included models, so you can tell which model class is consuming your quota rather than guessing.

In-App Settings > Account

Inside Cursor, open Settings with Ctrl/Cmd + , and select Account. This panel is read-mostly:

• A sign-out control
• A plan indicator for the current session
• A deep link to manage billing, which opens the browser dashboard
• The Settings Sync toggle

Plan changes and payment methods live on the web dashboard on purpose. Embedding payment UI in the editor would require handling card data in the client, so Cursor keeps that in the browser.

Reading the Usage Tab Correctly

The counters reset monthly on your renewal anchor date, not on the first of the calendar month. If your limits look wrong, confirm the anchor date before filing a ticket.

Usage resets on your billing cycle

A Pro plan that renews on the 17th resets usage on the 17th. Compare counters against that date, not the calendar month. Mismatched expectations about the reset date cause a large share of false "usage bug" reports.

Changing the Email on an Existing Account

There is no self-serve email change. You cannot open settings, edit the address, and expect your subscription, usage history, and synced settings to follow. The identity is bound to whichever provider you signed in with, and that binding is not user-editable.

The reliable path is to contact Cursor support and request either a manual email change or an account migration, with proof that you control both the old and the new address.

How to Find Your Account ID

Support will ask for your account ID. You can find it in two places:

• The in-app Settings > Account panel shows the account identifier near the sign-out control
• The web dashboard page source or account section exposes the same identifier

If you cannot find it, note that it is not your email address. It is an opaque identifier that support uses to locate the exact record.

Proof of Ownership

Because an email change is effectively an identity transfer, support needs evidence you own both addresses. The cleanest proof is the ability to send a verification message from each mailbox on request.

Support Ticket Template

Copy and adapt the following template. Keeping it structured speeds up the first response.

To: support (via the in-app Contact Support form or [email protected])
Subject: Request to change account email from [email protected] to [email protected]

Account ID: <paste from Settings > Account>
Current email: [email protected]
Requested email: [email protected]
Sign-in method: Email magic link | Google | GitHub

Reason for change:
  Migrating from a personal domain to a company domain.

Proof of ownership:
  - I can send a verification email from [email protected] on request
  - I can also send one from [email protected] on request

Subscription details (if active):
  Tier: Pro (annual)
  Invoice reference: <paste from dashboard>

Impact to preserve:
  - Usage history
  - Settings Sync state

Additional notes:
  <anything else support should know>

Never send your password or a session token

Support will not ask for your password, a magic-link URL, or a session token. If a message claiming to be support requests those, it is phishing. Share only the account ID and proof-of-ownership steps.

Expect the change to take a few business days and to require a fresh sign-in afterward. Plan for a brief window where a device may be signed out.

Merging Duplicate Accounts

Duplicate accounts are easy to create accidentally. A common pattern is signing up once with Google for a quick trial and then again with GitHub when you commit to a paid plan. Cursor does not merge accounts automatically, and there is no in-app merge button.

What you can do is request a merge through support:

• Identify both account IDs from the dashboard
• Confirm which record holds the active subscription; that is normally the record to keep
• Provide proof of ownership for both sign-in methods
• State explicitly that usage history from the secondary account may be dropped rather than combined

In practice, usage history and chat history are not carried over. The merge exists mainly to consolidate billing and to free the abandoned identity so it is not mistaken for a live account later.

Prevent duplicates before they happen

When you start a paid plan, keep using the same sign-in method you used on the free tier. If you must switch providers, do it through support as a change, not by signing up fresh. A fresh sign-up creates a new account rather than transferring the old one.

What Transfers Between Devices

Settings Sync is a feature that carries a subset of your configuration across machines where you are signed in. Knowing exactly what moves, and what does not, prevents a lot of confusion when you set up a second laptop.

What Syncs

• Editor settings, meaning your settings.json
• Keybindings, meaning your keybindings.json
• The list of installed extensions
• User snippets
• UI state such as the active theme and layout preferences

What Does Not Sync

• Chat history: stored locally on each machine, not in the cloud
• Rules files: .cursor/rules is per-project and travels with the repository
• MCP configuration: per-project or per-machine mcp.json
• Codebase index: embeddings are rebuilt locally for each machine

This split is deliberate. Things that define your personal editing feel travel with you; things that define a project stay with the project so teammates share one source of truth.

Enabling Settings Sync

Toggle it in Settings > General > Settings Sync, or set it directly:

// settings.json excerpt
{
  "settingsSync.enabled": true,
  "settingsSync.keybindingsPerPlatform": false
}

With keybindingsPerPlatform false, Cursor syncs a single keybinding set across operating systems instead of maintaining one per platform. That is convenient if you jump between macOS and Windows, but it can flatten platform-specific defaults.

Commit rules, sync editor preferences

Keep .cursor/rules and mcp.json inside the project repository so they travel with the code and stay consistent for teammates. Let Settings Sync handle editor-level preferences only. Separating the two sources of truth avoids drift where a rule silently changes because someone's personal sync overwrote it.

Device Limits and Managing Signed-In Machines

A single account can be used on multiple machines, and each sign-in is tracked as a session. This is what lets you review and revoke access when a device is lost or shared.

Reviewing Active Sessions

• Open the dashboard and locate the sessions or devices area
• Each entry shows a device label and a last-seen timestamp
• Unknown labels or unexpected locations are a signal to revoke

Deauthorizing Other Devices

Two equivalent paths exist:

• Sign out from within Cursor on the machine you no longer use
• Revoke the session from the dashboard, which forces that device to re-authenticate on its next action

Revoking from the dashboard is the stronger option because it does not depend on the device still being reachable.

Sign Out Everywhere

If a machine was lost, sold, or shared, revoke its session and rotate the credential behind your sign-in method:

• Change the password on your Google or GitHub account, or revoke Cursor's OAuth grant in that provider's settings
• Change the mailbox password if you signed in with a magic link

Rotating the provider credential invalidates tokens across the account, which is the closest thing to a global sign-out.

Deleting Your Account

Deletion is permanent and has two distinct scopes: what Cursor owns in the cloud, and what lives on your disk.

What Happens to Data

• Cloud: the account record, subscription linkage, usage history, and synced settings are removed
• Local: files on your disk are untouched, because Cursor never owned them
• Backups: deletion propagates through backups on a delayed schedule, so a restore window may exist for a short time

Export Before You Delete

Do this first, because deletion is not reversible:

• Copy any chat history you care about from local storage on each machine
• Save settings.json, keybindings.json, and all .cursor/rules files
• Download invoices from the dashboard for your own records
• Cancel the subscription explicitly, or billing may continue against a record you can no longer sign in to

Cancel billing before deleting

If you delete the account while an active subscription is attached, you may lose the ability to manage that subscription from the dashboard. Cancel the plan first, confirm the cancellation email, then proceed with deletion.

Keeping Work and Personal Accounts Separate

Mixing identities is the fastest way to leak work context into personal usage, or to find a personal extension enabled during a client demo. Keep the two worlds physically separate.

• Use separate OS user accounts so local application data never overlaps
• Install into separate directories so two Cursor instances can coexist
• Sign in with different providers: work through Google Workspace SSO, personal through GitHub
• Use distinct settings profiles so extension lists and keybindings do not bleed across

You can run a second, isolated instance with command-line flags:

# Launch a second instance with its own data and extensions directories
cursor --user-data-dir="$HOME/.cursor-work" --extensions-dir="$HOME/.cursor-work/extensions"

The isolated instance keeps its own chat history, its own indexed codebases, and its own accounts, which is exactly what you want when consulting or contracting across multiple clients.

Troubleshooting Common Account Issues

A handful of account problems show up repeatedly across support channels. Here is how to resolve them quickly.

Signed In but Everything Looks Locked

If Cursor shows your plan as Free even though your subscription is active, you are almost certainly signed in to a second, duplicate account created with a different provider. Compare the account ID shown in the app against the dashboard record. If they differ, use the merge path described above rather than buying a second plan.

The Magic Link Never Arrives

• Check the spam and promotions folders; magic-link mail is frequently filtered
• Confirm you typed the address you actually registered with, not an alias
• Wait a minute before requesting another link, because requesting a new one can invalidate the previous link
• If the mailbox is on a custom domain, verify that its DNS and spam filtering are not silently dropping the message

Settings Sync Is Not Applying

• Confirm Sync is enabled under Settings > General > Settings Sync
• Sign out and back in on the machine that is not updating
• Remember that chat history, rules, and MCP configuration never sync, so their absence is expected rather than a bug

The Subscription Shows the Wrong Seat Count

For team plans, seating is managed on the dashboard under billing. Removing a member frees a seat at the next cycle rather than immediately, so a mid-cycle count can look stuck when it is actually correct.

Account ID Mismatch Across Devices

Every device should report the same account ID. If two machines disagree, they are signed into different accounts. Settle on the account that holds the subscription, sign the others out, and sign them back in with the correct provider.

Check the account ID first

Nearly every "my plan vanished" or "sync is broken" report traces back to a duplicate account. Comparing account IDs across devices is the fastest single diagnostic you can run before opening a ticket.

Security Best Practices

A short checklist that covers most account risk:

• Sign in through a provider that enforces 2FA. If GitHub or Google already does, that protection carries into Cursor.
• Use a unique password wherever a password-based option exists.
• Review active sessions periodically and revoke anything you do not recognize.
• Treat a magic-link email as a live credential. Anyone who opens the link gets your session until it expires.
• On shared or borrowed machines, sign out when you finish, and sign out everywhere if you are unsure.
• Never paste a session token, magic link, or password into a chat, a ticket, or a third-party site that claims to "fix" your account.

A Quarterly Account Review

Once a quarter, spend five minutes on the following, which catches most problems before they escalate:

• Compare the account ID across every device you use, and reconcile any mismatch
• Revoke sessions you do not recognize
• Confirm the billing anchor date still matches your expectation
• Verify that your sign-in provider still enforces 2FA
• Back up settings.json, keybindings.json, and your .cursor/rules files

Accounts are the layer where billing, data, and device access all meet. A few minutes spent choosing the right sign-in method and reviewing sessions regularly saves hours of recovery later.