Auth0 CIMD registration appears incompatible with the current ChatGPT Client ID Metadata Document

I am trying to use Auth0 as the OAuth Authorization Server for an MCP server that is consumed by ChatGPT.

ChatGPT is using Client ID Metadata Document (CIMD) registration.

The ChatGPT Client ID Metadata Document is:

https://chatgpt.com/oauth/BpZIpxL-aggt/client.json

The document is publicly accessible and currently contains metadata similar to:

{
  "client_id": "https://chatgpt.com/oauth/BpZIpxL-aggt/client.json",
  "client_uri": "https://chatgpt.com/",
  "redirect_uris": [
    "https://chatgpt.com/connector/oauth/BpZIpxL-aggt"
  ],
  "token_endpoint_auth_method": "private_key_jwt",
  "token_endpoint_auth_methods_supported": [
    "none",
    "private_key_jwt"
  ],
  "grant_types": [
    "authorization_code",
    "refresh_token"
  ],
  "response_types": [
    "code"
  ],
  "client_name": "ChatGPT",
  "logo_uri": "https://persistent.oaistatic.com/sonic/misc/openai-logo.png",
  "token_endpoint_auth_signing_alg": "RS256",
  "jwks_uri": "https://chatgpt.com/oauth/jwks.json"
}

Problem

Auth0 successfully validates the ChatGPT CIMD using the preview endpoint, but the registration endpoint rejects the exact same document.

Step 1 — CIMD preview

I call:

curl -sS \
  -X POST "https://${AUTH0_DOMAIN}/api/v2/clients/cimd/preview" \
  -H "Authorization: Bearer ${AUTH0_MGMT_TOKEN}" \
  -H "Content-Type: application/json" \
  --data "$(jq -nc \
    --arg u 'https://chatgpt.com/oauth/BpZIpxL-aggt/client.json' \
    '{external_client_id:$u}')"

Auth0 returns:

{
  "mapped_fields": {
    "external_client_id": "https://chatgpt.com/oauth/BpZIpxL-aggt/client.json",
    "name": "ChatGPT",
    "callbacks": [
      "https://chatgpt.com/connector/oauth/BpZIpxL-aggt"
    ],
    "logo_uri": "https://persistent.oaistatic.com/sonic/misc/openai-logo.png",
    "grant_types": [
      "authorization_code",
      "refresh_token"
    ],
    "app_type": "regular_web",
    "jwks_uri": "https://chatgpt.com/oauth/jwks.json",
    "client_authentication_methods": {
      "private_key_jwt": {
        "credentials": [
          {
            "credential_type": "public_key",
            "kid": "cimd-20260428030119",
            "alg": "RS256"
          }
        ]
      }
    }
  },
  "validation": {
    "valid": true,
    "violations": [],
    "warnings": [
      "response_types is validated for format but is not persisted. This field is used for internal validation only.",
      "Ignoring unsupported properties: client_uri, token_endpoint_auth_methods_supported. These properties are not validated or mapped to the Auth0 client configuration."
    ]
  }
}

So the preview confirms that:

  • Auth0 can fetch the CIMD.

  • Auth0 can parse it.

  • Auth0 can fetch the JWKS.

  • The private_key_jwt credential is recognized.

  • The RS256 key and kid are recognized.

  • validation.valid is true.

  • There are no validation violations.

The only relevant warning is:

Ignoring unsupported properties:
client_uri, token_endpoint_auth_methods_supported

Step 2 — CIMD registration

I then call:

curl -sS -i \
  -X POST "https://${AUTH0_DOMAIN}/api/v2/clients/cimd/register" \
  -H "Authorization: Bearer ${AUTH0_MGMT_TOKEN}" \
  -H "Content-Type: application/json" \
  --data "$(jq -nc \
    --arg u 'https://chatgpt.com/oauth/BpZIpxL-aggt/client.json' \
    '{external_client_id:$u}')"

Auth0 returns:

HTTP/2 400

with:

{
  "statusCode": 400,
  "error": "Bad Request",
  "message": "The Client Metadata document at https://chatgpt.com/oauth/BpZIpxL-aggt/client.json cannot be applied. See /api/v2/clients/cimd/preview output for additional details.",
  "errorCode": "invalid_client_metadata"
}

The problem is that /cimd/preview does not provide any additional validation error.

It explicitly reports:

valid = true
violations = []

Potential interoperability issue

The ChatGPT CIMD contains both:

"token_endpoint_auth_method": "private_key_jwt"

and:

"token_endpoint_auth_methods_supported": [
  "none",
  "private_key_jwt"
]

My understanding is that ChatGPT is advertising support for both authentication methods while expressing private_key_jwt as its preferred method.

Auth0 currently reports that token_endpoint_auth_methods_supported is unsupported and ignores it.

This makes me wonder whether Auth0 is treating:

token_endpoint_auth_method = private_key_jwt

as a strict requirement rather than negotiating one of the mutually supported methods.

For example, if the Auth0 tenant cannot use private_key_jwt for this CIMD client, I would expect the Authorization Server to be able to select:

none

because ChatGPT explicitly advertises support for it in:

"token_endpoint_auth_methods_supported": [
  "none",
  "private_key_jwt"
]

There have been similar interoperability issues in other OAuth/MCP implementations when consuming the current ChatGPT CIMD format, particularly around the distinction between:

token_endpoint_auth_method

and:

token_endpoint_auth_methods_supported

Expected behavior

One of the following would be expected:

  1. /cimd/register successfully registers the client using a mutually supported token endpoint authentication method.

or:

  1. /cimd/preview reports a validation violation explaining exactly why the document cannot be applied.

Currently, the API behavior is inconsistent:

/cimd/preview
    ↓
valid = true
violations = []

/cimd/register
    ↓
400 invalid_client_metadata

Additional information

Dynamic Client Registration with the same ChatGPT/MCP integration works correctly against this Auth0 tenant.

The issue appears specific to CIMD registration.

The ChatGPT CIMD and JWKS are publicly reachable:

https://chatgpt.com/oauth/BpZIpxL-aggt/client.json
https://chatgpt.com/oauth/jwks.json

Questions

Could the Auth0 team clarify the following?

  1. Why does /api/v2/clients/cimd/preview return valid: true and no violations while /api/v2/clients/cimd/register rejects the same document with invalid_client_metadata?

  2. Is token_endpoint_auth_methods_supported currently supported by Auth0 CIMD?

  3. If it is not currently supported, is support planned?

  4. Does Auth0 currently perform authentication-method negotiation between the methods advertised by a CIMD client and the methods supported by the tenant?

  5. Is private_key_jwt being treated as mandatory because it appears in token_endpoint_auth_method, even though ChatGPT also advertises support for none?

  6. Is there any tenant setting, feature flag, subscription requirement, or configuration needed to make this ChatGPT CIMD register successfully?

  7. Is the difference between /cimd/preview succeeding and /cimd/register failing a known issue?

I can provide additional tenant logs or request details if needed.

Thanks.

Hi @davomeist

You are attempting to register ChatGPT as an OAuth client with Auth0 using Client ID Metadata Document (CIMD) registration. The CIMD preview endpoint successfully validates the ChatGPT metadata document and confirms it can be applied, but the registration endpoint rejects the exact same document with a 400 invalid_client_metadata error. The preview output shows valid: true and violations: [], creating an inconsistency between what the preview endpoint reports and what the registration endpoint accepts.

This is a known inconsistency in Auth0's CIMD implementation. The preview endpoint performs validation but does not perform all the same checks as the registration endpoint. The issue is likely related to how Auth0 handles the token_endpoint_auth_method field in combination with token_endpoint_auth_methods_supported, or a limitation in Auth0's current CIMD support. This requires investigation by Auth0 Support, as the behavior suggests either a bug in the registration endpoint or incomplete documentation of CIMD requirements.

Root Cause:

The inconsistency between /cimd/preview and /cimd/register indicates one of the following:

  1. Preview endpoint is incomplete — The preview endpoint validates the CIMD document structure and fetches the JWKS, but does not perform all the validation checks that the registration endpoint performs.
  2. Authentication method negotiation not implemented — Auth0 may not support the token_endpoint_auth_methods_supported field or may not perform negotiation between the client's advertised methods and the tenant's supported methods. If private_key_jwt is the only method Auth0 can use and the tenant cannot support it, registration fails even though the preview passes.
  3. Tenant-specific limitation — Your Auth0 tenant may not have CIMD support fully enabled, or there may be a feature flag or subscription requirement that is not documented.
  4. CIMD implementation gap — Auth0's CIMD support may not be complete for all OAuth 2.0 metadata fields, particularly around authentication method negotiation.

Solution: Contact Auth0 Support

This issue requires direct investigation by Auth0 Support because:

  1. The preview endpoint reports success — There are no validation violations to guide troubleshooting
  2. The error message is generic — invalid_client_metadata does not specify which field or validation rule failed
  3. The behavior is inconsistent — The same document passes preview but fails registration
  4. CIMD is a newer feature — It may have known limitations or bugs that are not yet documented

Recommended Steps:

Step 1: Gather Diagnostic Information

Collect the following before contacting Auth0 Support:

  1. Your Auth0 tenant name and region
  2. The exact CIMD URL: https://chatgpt.com/oauth/BpZIpxL-aggt/client.json
  3. The exact JWKS URL: https://chatgpt.com/oauth/jwks.json
  4. The full preview response (including the mapped_fields and validation sections)
  5. The full registration error response
  6. Your Auth0 subscription plan (to determine if CIMD is included)
  7. Whether you have any custom Rules or Actions that might affect client registration

Step 2: Verify CIMD Support

Confirm that CIMD is supported in your Auth0 plan:

  1. Navigate to Auth0 Dashboard → Applications → Applications
  2. Look for an option to register via CIMD or Client Metadata Document
  3. Check your subscription plan documentation to confirm CIMD is included

Step 3: Test with Dynamic Client Registration (DCR)

As a workaround, test whether Dynamic Client Registration works with ChatGPT:

  1. Enable Dynamic Client Registration in your Auth0 tenant
  2. Configure ChatGPT to use DCR instead of CIMD
  3. Verify that the OAuth flow works

This will help determine whether the issue is specific to CIMD or affects all ChatGPT registration methods.

Step 4: Contact Auth0 Support

Open a support ticket with Auth0 and provide:

  1. Issue description — CIMD preview succeeds but registration fails with invalid_client_metadata
  2. Diagnostic information — All items from Step 1
  3. Expected behavior — Either successful registration or a validation violation in the preview response
  4. Actual behavior — Preview returns valid: true but registration returns 400 invalid_client_metadata
  5. Questions for Auth0:
    • Why does /cimd/preview return valid: true when /cimd/register will reject the document?
    • Is token_endpoint_auth_methods_supported currently supported by Auth0 CIMD?
    • Does Auth0 perform authentication method negotiation, or does it require the exact method specified in token_endpoint_auth_method?
    • Is there a known issue with CIMD registration for ChatGPT or other clients that advertise multiple authentication methods?
    • Are there any tenant settings, feature flags, or subscription requirements needed for CIMD support?

Workaround: Use Dynamic Client Registration Instead

Until this is resolved, use Dynamic Client Registration (DCR) instead of CIMD:

  1. Enable DCR in your Auth0 tenant
  2. Configure ChatGPT to use DCR for registration
  3. This is the recommended approach for MCP servers according to Auth0 documentation

Why This Matters:

The inconsistency between preview and registration endpoints suggests:

  1. Incomplete validation — The preview endpoint may not be performing all necessary checks
  2. Documentation gap — The CIMD documentation may not explain all validation requirements
  3. Potential bug — The registration endpoint may be rejecting valid CIMD documents due to a bug
  4. Interoperability issue — Auth0 may not fully support the OAuth 2.0 CIMD specification

This issue requires Auth0 Support investigation. In the meantime, use Dynamic Client Registration as the workaround for ChatGPT MCP integration.

Kind Regards,
Nik

1 Like

Hi,

We’re looking to add a client for our ChatGPT plugin to auth0. I’d hoped to use CIMD and spotted your post.

Did you get a resolution?

Thanks

Hi,

Unfortunately, I don’t really know whether this issue has been resolved.

I’m using the Auth0 Free plan, and as far as I understand, Free users don’t have access to open direct support tickets with Auth0, so I wasn’t able to escalate the issue to their support team and get an official resolution.

After running into this problem, I eventually switched the Identity Provider / OAuth 2.0 provider to another provider that didn’t have this CIMD compatibility issue. Because of that, I’m no longer using Auth0 for this integration and can’t verify whether Auth0 has fixed the problem since I originally reported it here.

What I can confirm is that the workaround suggested by @nik.baleca worked for me: using an alternative client registration mechanism such as Dynamic Client Registration (DCR) allowed ChatGPT to authenticate successfully with Auth0.

So, at least at the time I tested it:

  • CIMD with the ChatGPT client metadata document was failing.

  • DCR worked correctly as an alternative.

  • I eventually moved to another OAuth provider with better support for the current ChatGPT CIMD implementation.

If you’re able to test CIMD with Auth0 now, I’d definitely be interested to know whether the behavior has changed.

1 Like