@@ -71,6 +71,62 @@ type EnrichedDetail = {
 /** The scope org auth tokens have, and that Sentry's CI endpoints accept. */
 const ORG_CI_SCOPE = "org:ci";
 
+/**
+ * Org slug of an org- or project-scoped API path. Anything that isn't a
+ * plain slug (escapes, IDs with other characters) yields no org to compare.
+ */
+const PATH_ORG_RE = /(?:^|\/)(?:organizations|projects)\/([\w-]+)\//;
+
+/** Numeric org IDs can't be compared with the slug in a token. */
+const NUMERIC_ORG_RE = /^\d+$/;
+
+/**
+ * Organization a failed request was for: from the raw request's endpoint,
+ * or from the response URL for SDK requests.
+ */
+function readTargetOrg(
+  response: Response,
+  endpoint: string | undefined,
+): string | undefined {
+  const path = endpoint ?? response.url;
+  return path ? PATH_ORG_RE.exec(path)?.[1] : undefined;
+}
+
+/**
+ * The org auth token's organization, when it differs from the one the
+ * request was for. An org auth token only works in its own organization:
+ * Sentry answers 403 when the target org is on the same server, and 401
+ * ("Invalid org token") when the token is unknown there.
+ *
+ * Reads the credential requests use ({@link getCredentialContext}), not
+ * `getAuthToken()`: a stored OAuth login that can still refresh is what the
+ * request sent, even when an env var also holds an org auth token. A stored
+ * `sntrys_` token (from `auth login --token`) counts too; an OAuth access
+ * token has no claim.
+ */
+function findOrgMismatch(
+  targetOrg: string | undefined,
+): { tokenOrg: string; targetOrg: string } | undefined {
+  if (!targetOrg || NUMERIC_ORG_RE.test(targetOrg)) {
+    return;
+  }
+  const tokenOrg = parseSntrysClaim(getCredentialContext()?.token)?.org;
+  if (!tokenOrg || tokenOrg.toLowerCase() === targetOrg.toLowerCase()) {
+    return;
+  }
+  return { tokenOrg, targetOrg };
+}
+
+function orgMismatchLines(mismatch: {
+  tokenOrg: string;
+  targetOrg: string;
+}): string[] {
+  return [
+    `This org auth token belongs to organization '${mismatch.tokenOrg}', but the request is for '${mismatch.targetOrg}'.`,
+    `Use an auth token created in '${mismatch.targetOrg}', or target '${mismatch.tokenOrg}' instead.`,
+  ];
+}
+
 /** How to name the token a request sent: its env var, or the stored one. */
 function tokenHolder(credential: CredentialContext | undefined): string {
   return credential?.source.startsWith("env:")
@@ -136,16 +192,19 @@ function acceptedScopeLines(acceptedScopes: string[]): string[] {
  * error would be actively wrong and has caused user confusion (CLI-SERVER-E).
  *
  * Then, in order:
+ * - an org auth token for another organization → name both organizations
  * - an `insufficient_scope` challenge → name the scopes the endpoint accepts
  * - env-var tokens → suggest checking token scopes
  * - OAuth tokens → suggest re-authentication
  *
  * @param acceptedScopes - Scopes from the response's `insufficient_scope`
  *   challenge; any one of them works
+ * @param targetOrg - Organization in the request path, when it names one
  */
 function enrich403Detail(
   rawDetail: string | undefined,
   acceptedScopes: string[],
+  targetOrg: string | undefined,
 ): EnrichedDetail {
   // Org-level policy — re-auth and token scope advice do not apply here.
   if (rawDetail?.includes("disabled this feature")) {
@@ -165,6 +224,12 @@ function enrich403Detail(
     lines.push(rawDetail, "");
   }
 
+  const mismatch = findOrgMismatch(targetOrg);
+  if (mismatch) {
+    lines.push(...orgMismatchLines(mismatch));
+    return { detail: lines.join("\n  "), denialReason: "org_mismatch" };
+  }
+
   if (acceptedScopes.length > 0) {
     lines.push(...acceptedScopeLines(acceptedScopes));
     return { detail: lines.join("\n  "), denialReason: "insufficient_scope" };
@@ -209,7 +274,7 @@ function enrich403Detail(
  * 401 means the token is missing, invalid, or expired — the identity cannot
  * be determined at all. Distinct from 403 (identity known, lacks permission).
  * Scope hints do not apply; the fix is always to re-authenticate or regenerate
- * the token.
+ * the token, unless it is an org auth token for another organization.
  *
  * The Sentry API returns distinct `detail` strings we can branch on:
  * `"Token expired"` when the token is past its expiry date, `"Invalid token"`
@@ -222,7 +287,10 @@ function enrich403Detail(
  *
  * @see https://github.com/getsentry/sentry/blob/934f1473f198a62f9268d7140b80cd9ca1e59bb9/src/sentry/api/authentication.py#L536-L539
  */
-function enrich401Detail(rawDetail: string | undefined): EnrichedDetail {
+function enrich401Detail(
+  rawDetail: string | undefined,
+  targetOrg: string | undefined,
+): EnrichedDetail {
   // Seat-limit lockout, not an auth failure. Sentry returns 401 with
   // `code: member-disabled-over-limit` when the org is over its member limit
   // and the caller's seat is disabled — re-authenticating cannot fix this.
@@ -242,6 +310,12 @@ function enrich401Detail(rawDetail: string | undefined): EnrichedDetail {
   if (rawDetail) {
     lines.push(rawDetail, "");
   }
+  const mismatch = findOrgMismatch(targetOrg);
+  if (mismatch) {
+    lines.push(...orgMismatchLines(mismatch));
+    return { detail: lines.join("\n  "), denialReason: "org_mismatch" };
+  }
+
   const expired = rawDetail?.toLowerCase().includes("expired") ?? false;
   // Advise on the credential the request sent, which can be a stored login
   // even when an env var also holds a token.
@@ -290,16 +364,21 @@ function enrichDetail(
   response: Response,
   detail: string | undefined,
   hasUsableDetail: boolean,
+  endpoint?: string,
 ): { detail: string | undefined; denialReason?: ApiDenialReason } {
   const { status } = response;
   if (status === 403) {
     return enrich403Detail(
       hasUsableDetail ? detail : undefined,
       parseInsufficientScopeChallenge(response.headers.get("www-authenticate")),
+      readTargetOrg(response, endpoint),
     );
   }
   if (status === 401) {
-    return enrich401Detail(hasUsableDetail ? detail : undefined);
+    return enrich401Detail(
+      hasUsableDetail ? detail : undefined,
+      readTargetOrg(response, endpoint),
+    );
   }
   return { detail };
 }
@@ -1038,7 +1117,12 @@ export async function throwRawApiError(
     "x-sentry-error": response.headers.get("x-sentry-error"),
     "www-authenticate": response.headers.get("www-authenticate"),
   });
-  const enriched = enrichDetail(response, detail, detail !== undefined);
+  const enriched = enrichDetail(
+    response,
+    detail,
+    detail !== undefined,
+    endpoint,
+  );
   throw new ApiError(
     `${context}: ${response.status} ${response.statusText}`,
     response.status,
 
@@ -253,7 +253,7 @@ function recordSilencedError(error: unknown, reason: SilenceReason): void {
 
   // Structured log for user API errors — `detail` is often the most actionable
   // field and is searchable in Sentry Logs. A 401/403 logs its denial reason
-  // instead: its detail is the CLI's own guidance, not the server's.
+  // instead: its detail is the CLI's own guidance, which can name orgs.
   if (reason === "api_user_error" && error instanceof ApiError) {
     // oxlint-disable-next-line sentry-cli/no-silent-catch -- grandfathered silent catch — see #1531; drain by adding log.debug()/log.warn() or re-throwing.
     try {
 
@@ -180,6 +180,7 @@ export type FunctionArgument = {
  * words such as "auth" and "token" in new values; Sentry's data scrubbing
  * replaces values that contain them with `[Filtered]`.
  *
+ * - `org_mismatch`: an org auth token for another organization
  * - `insufficient_scope`: the token lacks every scope the endpoint accepts
  * - `member_policy`: an org setting blocks members from the action
  * - `seat_limit`: the member is disabled because the org is over its limit
@@ -189,6 +190,7 @@ export type FunctionArgument = {
  *   or created on another server)
  */
 export type ApiDenialReason =
+  | "org_mismatch"
   | "insufficient_scope"
   | "member_policy"
   | "seat_limit"
 
@@ -440,9 +440,9 @@ export function isUserApiError(error: unknown): boolean {
  * `api_error.denial_reason` (401/403) or `api_error.detail` on the span. Must
  * be called before `span.end()`.
  *
- * A 401/403 detail is the CLI's own guidance rather than the server's, and
- * Sentry's data scrubbing replaces most of them with `[Filtered]`. The denial
- * reason is a fixed category that tells those failures apart instead.
+ * A 401/403 detail is the CLI's own guidance, which can name organizations,
+ * and Sentry's data scrubbing replaces most of them with `[Filtered]`. The
+ * denial reason is a fixed category that tells those failures apart instead.
  *
  * @internal Exported for testing
  */
 
@@ -820,6 +820,60 @@ describe("throwApiError", () => {
 // isTextualContentType + rawApiRequest binary handling (getsentry/cli#1303)
 // ---------------------------------------------------------------------------
 
+describe("org auth token org mismatch", () => {
+  useTestConfigDir("api-org-mismatch-");
+  useEnvSandbox([
+    "SENTRY_AUTH_TOKEN",
+    "SENTRY_TOKEN",
+    "SENTRY_FORCE_ENV_TOKEN",
+  ]);
+
+  /** The detail of a denial for `path`, sent with an org auth token for `tokenOrg`. */
+  function detailFor(
+    tokenOrg: string,
+    status: 401 | 403,
+    path: string,
+    detail = "Denied",
+  ): string | undefined {
+    const claim = Buffer.from(
+      JSON.stringify({ iat: 1, url: "https://sentry.io", org: tokenOrg }),
+    ).toString("base64");
+    process.env.SENTRY_AUTH_TOKEN = `sntrys_${claim}_secret`;
+    process.env.SENTRY_FORCE_ENV_TOKEN = "1";
+    resetAuthTokenCache();
+    const body = { detail };
+    const response = Response.json(body, { status });
+    // SDK requests carry the request URL on the response.
+    Object.defineProperty(response, "url", {
+      value: `https://us.sentry.io/api/0/${path}`,
+    });
+    try {
+      throwApiError(body, response, "Failed");
+    } catch (error) {
+      return (error as ApiError).detail;
+    }
+    throw new Error("expected throwApiError to throw");
+  }
+
+  test.each([
+    [403, "organizations/target-org/releases/", "Denied"],
+    [401, "projects/target-org/web/releases/", "Invalid org token"],
+  ] as const)("names both orgs on a %i", (status, path, detail) => {
+    expect(detailFor("token-org", status, path, detail)).toContain(
+      "This org auth token belongs to organization 'token-org', but the request is for 'target-org'.",
+    );
+  });
+
+  test.each([
+    ["token-org", "organizations/12345/releases/"],
+    ["Token-Org", "organizations/token-org/releases/"],
+  ])("skips the hint for a %s token on %s", (tokenOrg, path) => {
+    expect(detailFor(tokenOrg, 403, path)).not.toContain(
+      "belongs to organization",
+    );
+  });
+});
+
 describe("403 scope challenge guidance", () => {
   useTestConfigDir("api-denial-");
   useEnvSandbox([
Original file line number	Diff line number	Diff line change
`@@ -440,9 +440,9 @@ export function isUserApiError(error: unknown): boolean {`
`440`	`440`	* `api_error.denial_reason` (401/403) or `api_error.detail` on the span. Must
`441`	`441`	* be called before `span.end()`.
`442`	`442`	`*`
`443`		`- * A 401/403 detail is the CLI's own guidance rather than the server's, and`
`444`		- * Sentry's data scrubbing replaces most of them with `[Filtered]`. The denial
`445`		`- * reason is a fixed category that tells those failures apart instead.`
	`443`	`+ * A 401/403 detail is the CLI's own guidance, which can name organizations,`
	`444`	+ * and Sentry's data scrubbing replaces most of them with `[Filtered]`. The
	`445`	`+ * denial reason is a fixed category that tells those failures apart instead.`
`446`	`446`	`*`
`447`	`447`	`* @internal Exported for testing`
`448`	`448`	`*/`