Claude Platform Docs
管理Claude Platform OAuth

Linked billing

顧客がOAuthを使用して自身のClaude Platform組織をアプリにリンクできるようにし、Claudeの使用量を顧客の組織に請求します。

Linked billingを使用すると、顧客は自身のClaude組織を通じて、アプリ内でのClaudeの使用量を支払うことができます。顧客は自身のClaude組織をアプリに一度リンクします。APIではこのリンクを「connection」(接続)と呼びます。顧客がリンクした後は、各Claude APIリクエストごとに、顧客とあなたのどちらが支払うかを選択します。顧客はいつでもアプリのリンクを解除できます。顧客への請求を指定したリクエストを顧客に請求できない場合、Claude APIはあなたに請求するのではなく、そのリクエストを拒否します。

このガイドは、アプリのユーザーが主にClaude Platformの顧客である開発者を対象としています。アプリに「Link your Claude organization」ボタンを追加します。ユーザーがそれをクリックし、Claudeにサインインして、顧客の指示によってあなたが行うClaude APIリクエストの料金を、アプリがそのユーザーのClaude組織に請求することを承認します。その後、アプリは顧客が支払うリクエストにbilling_policyフィールドを追加します。

対象となる顧客とエンドポイント

対象となる顧客: この方法で請求できるのは、顧客のClaude Platform組織がAPI使用量の料金をAnthropicに直接支払っている場合のみです。前払いクレジットと請求書払いのどちらも対象となります。クラウドマーケットプレイス(AWS、Google Cloud、またはAzure)を通じて請求される組織は、この統合を通じて請求できません。Claudeのサブスクリプションプランのみを利用している組織も同様です。それらの組織向けのリクエストは403 user_profile_not_billableで拒否されます。

リクエストはあなたの組織内で実行されるため、あなたのレート制限、モデルへのアクセス、サービスティア、データ保持、および暗号化キーが適用されます。これらのリクエストには、「zero data retention」(ゼロデータ保持)、すなわちZDR、「business associate agreement」(事業提携契約)、すなわちBAA、「customer-managed encryption keys」(カスタマー管理の暗号化キー)、すなわちCMEKなど、顧客自身のデータに関する取り決めは適用されません。この使用量についてHIPAA、FERPA、またはCMEKによる保護を必要とする顧客はリンクしないでください。

サポートされているエンドポイント: billing_policyは以下でサポートされています:

  • /v1/messages
    • 既知の制限:顧客に請求するリクエスト(bill_to: "user_profile")では、課金対象のコード実行機能を使用できません(APIは400を返します)。そのため、これらのリクエストはbill_to: "self"を指定するか、billing_policyなしで送信してください。
  • /v1/chat/completions
  • /v1/messages/count_tokensはbilling_policyフィールドを受け付けますが無視するため、送信しようとしているのとまったく同じボディでトークン数をカウントできます。

Message Batches(/v1/messages/batches)は、現在、顧客への請求に対応していません。バッチ内のリクエストは bill_to: "self" を指定するか、billing_policy を指定せずに送信してください。そうすれば、通常どおりあなたに請求されます。バッチ内で bill_to: "user_profile" を設定したリクエストは拒否されます。その結果は invalid_request_error を伴う errored となり、あなたにも顧客にも請求されず、バッチ内の他のリクエストは通常どおり実行されます。

他のエンドポイントでのサポートを希望する場合は、Anthropicのアカウントチームにお問い合わせください。

支払いに使用できるクレジット

プラットフォームが顧客に請求するリクエストの支払いには、すべてのクレジットを使用できるわけではありません。支払いに使用できるものは、請求先の組織によって異なります。あなたが顧客に請求する場合は顧客、プラットフォームがあなたに請求する場合はあなたの組織が請求先となります。

その組織のためにClaude Consoleで購入したクレジットは、これらのリクエストの支払いに使用できます。その組織が請求書払いの場合は、これらのリクエストの料金が請求書で請求されます。

Anthropicからの一部のプロモーションクレジットは、これらのリクエストの支払いに使用できません。これには、Claude Max、Ultra、およびTeamプランに付属する月間APIクレジットが含まれます。Anthropicのパートナー、VC、およびスタートアップ向けプログラムのクレジットは、これらのリクエストの支払いの対象外です。

その組織のアカウントにリクエストの支払いに使用できるものが何もない場合、Claude APIはそのリクエストを402で拒否することがあります。レスポンスには、拒否の原因がクレジット不足なのか支出制限なのかは示されません。想定されるエラーを参照してください。

セットアッププロセス

以下の3つのステップは一度だけ行います。これらのステップでアプリをAnthropicに登録します。その後のリンクするユーザープロファイルでは、ユーザープロファイルを作成する前に把握しておく必要があるルールについて説明します。

ステップ1:アプリを作成する

Claude ConsoleでOAuthアプリを作成します。これはあなたの製品をAnthropicに対して識別する登録情報です。リダイレクトURIをクライアントIDに紐付け、その名前がユーザーの承認ページに表示されます。

管理者ロールを持つ組織のメンバーが、ConsoleのOAuthアプリページを開き、作成をクリックします。アプリの名前とリダイレクトURI(承認後にブラウザが戻る、アプリ内のアドレス)を入力します。What the app can doで、Bill and link to organizationsを選択します。

新しいアプリのページが開きます。Consoleに表示されるアプリのクライアントIDをコピーします。アプリは、ステップ5で承認ページをリクエストするとき、ステップ6でブラウザをリダイレクトするとき、ステップ8でコードを交換するときにこれを送信し、どのアプリからのリクエストかをAnthropicが識別できるようにします。クライアントIDは公開情報です。外観タブで、アプリの名前、ホームページ、ロゴURLを設定します。

設定タブでは、新しいアプリはテスト中の状態で始まるため、Who can linkはTest users onlyと表示されます。アプリを公開して本番稼働すると、この設定はAny Claude userと表示されます。

ステップ2:クライアント認証を設定する

バックエンドがauth.claude.comに対して、そのリクエストがあなたのアプリから送信されたものであることを証明する方法を設定します。これはクライアントシークレットの代わりとなります。AnthropicはOAuthアプリに対してクライアントシークレットを発行しません。

アプリのClient authenticationタブで、ID プロバイダー(バックエンドのトークンに署名する発行者)を選択します。追加するには、Register a new issuerをクリックします。次に、それらのトークンが一致する必要があるサブジェクトパターン、または詳細な一致オプションの下のクレーム条件を設定します。保存すると、タブに期待されるオーディエンスが表示されます。クライアントアサーションのaudクレームは、その値と完全に一致する必要があります。

ステップ3:バックエンドのアイデンティティを設定する

バックエンドがClaude APIを呼び出すには、独自のアイデンティティが必要です。次の2つを作成します:

  • 「service account」(サービスアカウント)。 これは、Claude組織内の人間以外のアカウントです。バックエンドはClaude APIを呼び出す際に、このアカウントとして認証します。
  • 2つ目のフェデレーションルール。 ステップ2のアプリのクライアント認証用のルールと同様に、バックエンドが独自のアイデンティティプロバイダーからのトークンで認証できるようにします。

Claude Consoleでこれらを設定するには、Workload Identity Federationガイドに従ってください。

次に、アプリのClient authenticationタブで、そのサービスアカウントをアプリのオペレーターサービスアカウントとして選択します。推論リクエストを送信し、リンクされたユーザープロファイルに請求を帰属させることが許可されているのは、そのサービスアカウントのみです。1つのサービスアカウントがオペレーターになれるのは、1つのOAuthアプリのみです。

デフォルトでは、そのサービスアカウントとして認証された任意のリクエストが、Messages APIでユーザープロファイルヘッダーとbill_toを設定することで、リンク済みのすべての顧客に請求できます。特定の接続のみに制限された認証トークンを取得するには、接続ごとのOAuthトークンを参照してください。顧客をリンクする前に、アプリのワークスペースを設定してください。ステップ8では顧客ごとにこのようなトークンが返されますが、そのためにはアプリで、推論を実行する組織内のデフォルトのワークスペースを指定する必要があります。接続ごとの「refresh token」(リフレッシュトークン)が必要な場合は、アプリのOffline accessも有効にしてください。その後、顧客をリンクする前に、ステップ5の認可フローでoffline_accessをリクエストしてください。

「user profile」(ユーザープロファイル)は、あなたの顧客の1人を表す、あなた自身のClaude組織内のレコードです。顧客に請求する各リクエストにはプロファイルのIDが含まれるため、Anthropicはどの顧客に請求するかを識別できます。プロファイルのその他の機能については、エンドカスタマーへの帰属のためのユーザープロファイルを参照してください。

最初の顧客をリンクする前に、各顧客をどのユーザープロファイルで表すかを決めておいてください。1つのアプリ内では、接続は1対1です:

  • 顧客のClaude組織は、あなたのユーザープロファイルのうち1つにのみリンクできます。
  • ユーザープロファイルは、1つのClaude組織にのみリンクできます。

顧客のClaude組織とは、ユーザーがアプリを承認する際に選択する組織です。顧客のチームがClaude組織をどのように使用しているかは、顧客に尋ねてください。1対1のルールを顧客レコードに適用するには:

  • 1つの顧客の複数のチームが1つのClaude組織を共有している場合: すべてのチームに1つのユーザープロファイルを使用してください。
  • 各チームが独自のClaude組織を持っている場合: 組織ごとにユーザープロファイルを作成してください。

1対1のルールの範囲内で、あなたの組織内の任意のアクティブなユーザープロファイルをリンクできます。リンクによって、プロファイル、そのID、またはその使用履歴が変更されることはありません。すでにリンク済みのClaude組織に2つ目のユーザープロファイルをリンクすると、承認は拒否されます。user_profile_already_linkedを参照してください。

個人ごとのユーザープロファイル

製品を使用する各個人のユーザープロファイルをすでに作成している場合があります。そのうちの複数の人が同じ顧客のために働いている場合もあります。その場合、Anthropicは、顧客のClaude組織用にもう1つユーザープロファイルを作成し、そのプロファイルをリンクすることを推奨します。

送信するプロファイルIDは、リクエストの支払者によって異なります:

  • 顧客に請求するリクエスト: 顧客のプロファイルのIDを送信します。/v1/messagesリクエストで個人も識別するには、metadata.user_idAPI リファレンスへのリンクを含むプレビューを表示できます — カードにフォーカスが移るまで Tab キーを押します。戻るには Escape キーを押します。をその人の識別子に設定します。この識別子は任意であり、Anthropicが1人の人物による不正使用を検出するのに役立ちます。名前、メールアドレス、電話番号ではなく、不透明な値を使用してください。
  • あなたが支払うリクエスト: 引き続きその人自身のプロファイルIDを送信できます。

各顧客をリンクする

ステップ4から8は、組織をリンクする顧客ごとに行います。以下のPythonコードスニペットには、Anthropic SDKといくつかの標準インポートが必要です。コードスニペットの初期化を参照してください。他の言語の例とCLIは、環境から認証情報を取得します。アプリはWorkload Identity Federationで認証する必要があるため、ANTHROPIC_API_KEYが設定されていないことを確認してください。

製品内で顧客が請求や統合を管理する場所に「Link your Claude organization」ボタンを追加します(ボタンのHTML、色、ロゴについては、ブランディングサンプルを参照してください)。リンクするには、Claude組織の管理者または請求のロールを持っている必要があることを顧客に伝えてください。

まず自分で手順を試すには、顧客としてテストするを参照してください。

ブラウザ
バックエンド
auth.claude.com
「Link your Claude organization」⁠を​クリックする
5
ユーザープロファイルIDと​クライアントアサーションを​含むプッシュ​型​認可​リクエスト
request_uri
6
承認​ページ(認可エンドポイント)⁠に​リダイレクトする
7
ユーザーが​Claudeに​サインインし、組織を​選択して​承認する
ワンタイムコードと​stateを​付けて​リダイレクトURIに​リダイレクトする
コードと​stateを​渡す
stateが​一致することを​確認する
8
コード、PKCEコードベリファイア、クライアントアサーションを​含むトークンリクエスト
connection_id
接続IDを​顧客の​レコードに​保存する

ステップ4:顧客のユーザープロファイルを作成する

顧客のClaude組織ごとに1つのユーザープロファイルを作成し、そのプロファイルのIDを製品内の顧客レコードに保存します。

この顧客のClaude組織用のユーザープロファイルがすでにある場合は、このステップをスキップし、そのプロファイルのIDを使用してください。それがどのプロファイルかを判断するには、リンクするユーザープロファイルを参照してください。

def create_user_profile(name: str, customer_id: str) -> str:
    profile = client.user_profiles.create(
        name=name,
        external_user_details={"reference_id": customer_id},
    )
    return profile.id  # "uprof_..."


user_profile_id = create_user_profile("Example Customer Inc.", "your-customer-id-123")

あなたの組織がAPIアクセスを再販している場合は、このプロファイルを作成する際に"access_type": "passthrough"も送信してください。これらのサンプルではaccess_typeを省略しているため、applicationプロファイルが作成されます。2つのタイプについては、プロファイルを付与する対象を決めるを参照してください。

レスポンスにはプロファイルのid(例:uprof_01HV9Z)が含まれます。

ステップ5:プッシュ型認可リクエストURLを作成する

ステップ4の顧客のユーザープロファイルを参照する「pushed authorization request」(プッシュ型認可リクエスト)を作成します。レスポンスでrequest_uriが返されます。次のステップでは、これを使用してユーザーを承認ページにリダイレクトします。

リクエストを送信する前に、バックエンドは2つのランダムな値を作成し、ブラウザセッションと顧客レコードに関連付けて保存します。どちらもステップ8で再度使用します:

  • state値。アプリに戻ってきたブラウザが、このリクエストを開始したブラウザと同じであることを確認するために使用します。
  • PKCEコードベリファイア。バックエンドだけが知っているシークレットです。リクエストにはそのハッシュ(コードチャレンジ)が含まれ、ステップ8ではベリファイア自体を送信するため、返されたコードを使用できるのはバックエンドだけになります。
def push_authorization_request(user_profile_id: str) -> dict:
    state = secrets.token_urlsafe(32)
    code_verifier = secrets.token_urlsafe(64)
    code_challenge = create_s256_code_challenge(code_verifier)

    response = httpx.post(
        f"{AUTH}/v1/oauth/par",
        json={
            "response_type": "code",
            "client_id": CLIENT_ID,
            "redirect_uri": REDIRECT_URI,
            "scope": "billing:attribution",
            "connection_type": "organization_shared",
            "connection_auth_target": "platform",
            "user_profile_id": user_profile_id,
            "state": state,
            "code_challenge": code_challenge,
            "code_challenge_method": "S256",
            "client_assertion_type": JWT_BEARER,
            "client_assertion": client_assertion(),
        },
    )
    response.raise_for_status()  # on an error, do not redirect the browser

    return {
        "state": state,
        "code_verifier": code_verifier,
        "request_uri": response.json()["request_uri"],  # valid for 600 seconds
        "user_profile_id": user_profile_id,
    }


par = push_authorization_request(user_profile_id)

auth.claude.comは、HTTP 201、request_uri、および600秒のexpires_inを返します。request_uriは、このリクエストの承認ページを識別します。scopeは正確にbilling:attributionまたはbilling:attribution offline_accessである必要があります。詳細については、請求接続のスコープを参照してください。例ではbilling:attributionを送信しています。アプリにこのスコープがない場合は、アプリのPermissionsタブのBillingで追加してください。

connection_auth_targetはplatformである必要があります。推論リクエストはあなた自身の組織内で実行され、オペレーターサービスアカウントとして認証しますが、顧客に請求できます。

user_profile_idは組織内のアクティブなユーザープロファイルのIDである必要があります。プッシュ型認可リクエストが失敗した場合、auth.claude.comはバックエンドにOAuthエラーレスポンスを返します。その場合、ブラウザをリダイレクトしないでください。

ステップ6:ユーザーをClaudeの承認ページに送る

まず、製品内のどのアカウントをリンクしようとしているかをユーザーに示し、承認ページに表示されるClaudeアカウントを確認するようユーザーに伝えてください。ページには、どのClaudeアカウントでサインインしているかが表示され、ユーザーは別のアカウントに切り替えることができます。承認ページは、ブラウザでサインインしているClaudeアカウントの組織のみを提示するため、誤ったアカウントで誤った組織がリンクされる可能性があります。支払うのは、ユーザーがリンクした組織です。

次に、ユーザーを、承認ページを表示する認可エンドポイントにリダイレクトします。client_idとステップ5のrequest_uriのみを含めてください。

def authorize_url(par: dict) -> str:
    query = urlencode({"client_id": CLIENT_ID, "request_uri": par["request_uri"]})
    return f"{AUTH}/oauth/authorize?{query}"


redirect_to = authorize_url(par)  # answer the click with a 302 to this URL

ステップ7:ユーザーが承認する

このステップでは、アプリは何も行いません。ユーザーはauth.claude.comで以下の手順を進めます:

  1. ブラウザがすでにサインインしている場合を除き、ユーザーはClaudeにサインインします。
  2. 承認ページには、それぞれアプリの名前を含む以下の画面が表示されます。各画面でユーザーが行うことについては、リンクを参照してください。
    1. Select an organization。ユーザーが組織を選択できる場合のみ表示されます。
    2. How billing works。
    3. Set a monthly spend limit。
    4. Link and authorizeボタンのある最後の画面。
  3. ユーザーがLink and authorizeをクリックすると、auth.claude.comはブラウザをアプリに戻します。承認ページには確認画面は表示されません。

ユーザーがキャンセルした場合や承認できない場合、接続は行われません。リンクが完了しない場合を参照してください。

ステップ8:コールバックを処理して接続を保存する

承認後、auth.claude.comは1回限りのコードとstate値を付けて、ブラウザをリダイレクトURIに戻します。このリダイレクトURIへのリクエストはコールバックと呼ばれます。バックエンドはコードを接続IDと交換し、それを顧客レコードに保存します。これで接続が完了します。コールバックには、コードの代わりにerrorパラメータが含まれる場合があります。その場合、接続は行われていません。リンクが完了しない場合を参照してください。

stateがステップ5で保存した値と一致することを確認してから、PKCEコードベリファイアとともに、バックエンドから直ちにコードを交換します。コードは1回のみ使用可能で、5分後に期限切れになります。

def handle_callback(par: dict, params: dict) -> str:
    if not secrets.compare_digest(
        params.get("state", "").encode(), par["state"].encode()
    ):
        raise ValueError("state does not match")
    if "error" in params:  # for example access_denied
        raise PermissionError(params["error"])
    code = params["code"]  # single-use, expires after 5 minutes
    response = httpx.post(
        f"{AUTH}/v1/oauth/token",
        json={
            "grant_type": "authorization_code",
            "code": code,
            "code_verifier": par["code_verifier"],
            "redirect_uri": REDIRECT_URI,
            "client_id": CLIENT_ID,
            "client_assertion_type": JWT_BEARER,
            "client_assertion": client_assertion(),
        },
        timeout=10,  # a response that times out loses the tokens in it
    )
    response.raise_for_status()
    tokens = response.json()
    # 接続のトークンを使用するには、tokens["access_token"]、その有効期限
    # (tokens["expires_in"] から算出)、および offline_access がある場合は
    # tokens["refresh_token"] をここでシークレットとして保存します。コードは再交換できません。
    # "ocon_..."。顧客レコードに保存します
    return tokens["connection_id"]

レスポンスには接続IDと接続のアクセストークンが含まれます。このアクセストークンで認証し、承認した顧客に請求できます。顧客がoffline_accessを承認した場合、レスポンスにはリフレッシュトークンも含まれます。connection_idとトークンはこの時点で保存してください。交換でトークンが返されるのは1回だけです。レスポンスについてはトークンを保存するで説明しています。

このページでClaude APIを呼び出す例は、このレスポンスのトークンではなく、ステップ3のサービスアカウントとして認証します。代わりにトークンを使用する方法については、接続のアクセストークンでClaudeを呼び出すを参照してください。

レスポンスは、ユーザーがどのClaude組織をリンクしたかを示しません。

接続が完了しても、Anthropicが顧客に請求できることが保証されるわけではありません。たとえば、顧客の組織が対象となる顧客に該当しない可能性があります。Claude APIがこれをどのように確認するかについては、Claudeへの呼び出しを更新すると想定されるエラーを参照してください。この確認があるため、成功メッセージは「請求が有効」ではなく「リンク済み」という表現にしてください。

交換がunauthorized_clientで拒否された場合は、コード交換がunauthorized_clientを返すを参照してください。

顧客としてテストする

リンクが機能することを確認するには、自身の組織をリンクします。まず以下が必要です:

  • 顧客として機能する、あなたが所有する2つ目のClaude組織。アプリを所有している組織にそのアプリをリンクすることはできません。承認ページにはその組織が表示されません。2つ目の組織は対象となる顧客のいずれかである必要があります。
  • リンクを承認する、その組織で管理者または請求のロールを持つ人。
  • アプリが本番稼働するまでは、その人がアプリのTest usersリストに含まれている必要があります。このリストは、アプリの設定タブのWho can linkの下にあります。その人のClaudeアカウントのメールアドレスで追加し、Save changesをクリックします。適用される支出上限については、アプリのテスト中を参照してください。リストから人を削除すると、その人が承認したリンクが終了します。

次に、ステップ4から8を実行し、ステップ7でその人に承認してもらいます。リンクが完了すると、ConsoleのUser profilesページで、ユーザープロファイルがLinkedと表示されます。

リンクが完了しない場合

ユーザーが承認を完了しない場合、またはauth.claude.comが承認を拒否した場合、接続は行われません。以下の項目では、Linked billingに固有の結果について説明します。その他のすべてのエラーについては、OAuthリファレンスのエラーを参照してください。

リダイレクトURIがerror=access_deniedを受け取る

リクエストにはstate値も含まれます。リダイレクトURIは、たとえば以下のような場合にこのエラーを受け取ります:

  1. ユーザーがいずれかの承認画面でCancelをクリックした。
  2. 承認ページにユーザーに提示できる組織がなく、ユーザーがアプリに戻るボタンをクリックした。たとえば:
    • ユーザーがどのClaude Platform組織でも管理者または請求のロールを持っていない。
    • ユーザーの唯一の組織が、アプリを所有している組織である。顧客としてテストするを参照してください。
    • ユーザープロファイルがすでに別のClaude組織にリンクされており、ユーザーがその組織で管理者または請求のロールを持っていない。
    • アプリが本番稼働するまでの間、ユーザーがそのTest usersリストに含まれていない。

このリストのいずれの場合でも、error_descriptionはthe user declined the requestとなるため、これらを区別する手段にはなりません。

もう1つの原因はアプリの設定にあります。アプリが本番稼働していて、Who can linkに自身の組織のみが表示されている場合、組織外の誰もアプリをリンクできません。Any Claude userを選択してSave changesをクリックしてください。

リンクが完了しなかったことをユーザーに伝え、ユーザーが拒否したとは決めつけないでください。どのClaudeアカウントでサインインしたか、およびリンクしたい組織でのロールを確認するようユーザーに依頼してください。ユーザーがキャンセルまたは戻った後はrequest_uriを再度使用できないため、ユーザーに再試行してもらうには、ステップ5からやり直してください。

アプリがuser_profile_already_linkedを受け取る

顧客のClaude組織が、あなたの別のユーザープロファイルを通じて、すでにアプリにリンクされています。auth.claude.comはユーザーにあなたへの問い合わせを求めます。ユーザーがアプリに戻った場合、リダイレクトURIはerror=user_profile_already_linkedとstate値を受け取ります。ステップ8でコードを交換する際に、トークンエンドポイントがこのエラーを返すこともあります。これは、たとえばその間に組織が別のユーザープロファイルを通じてリンクされた場合に起こります。

Anthropicは、顧客がどのClaude組織をリンクするかをあなたに伝えないため、これを事前に知ることはできません。ステップ5のプッシュ型認可リクエストは成功し、auth.claude.comはユーザーが承認する時点で初めて接続を拒否します。

このエラーは、接続を保持しているユーザープロファイルを示しません。最も可能性が高いのは、この顧客の別のリンク済みプロファイルです。Anthropicはプロファイルがどの組織にリンクされているかを表示しないため、対応する前に顧客に確認してください。そのプロファイルが接続を保持している場合は、以下のいずれかを行ってください:

  • この顧客に請求するリクエストで、そのユーザープロファイルのIDを送信する。
  • 顧客のリンクを解除するの説明に従ってその接続を終了し、拒否されたユーザープロファイルでステップ5から8を再度実行する。

この顧客のプロファイルがいずれもリンクされていない場合、ユーザーがあなたの別の顧客に属する組織を選択した可能性があります。ステップ5からやり直し、どの組織を選択するかをユーザーに確認してもらってください。

リダイレクトURIが何も受け取らない

アプリは以下の2つのケースを検出できません:

  • ユーザーが承認ページを閉じた。
  • request_uriの有効期限が切れている、またはすでに使用されている。この場合、承認ページはエラーを表示し、ブラウザをアプリに戻しません。

ユーザーがコールバックなしで製品に戻ってきた場合は、ステップ5からやり直してください。使用されなかったrequest_uriは、作成してから10分後に期限切れになります。

コード交換がunauthorized_clientを返す

アプリがこのリクエスト用に設定されていません。ワークスペースの問題の場合、error_descriptionに原因が示されます。オペレーターサービスアカウントがない場合は、the client is not registered for this grantとだけ表示されます。拒否によってコードが消費されることはないため、期限が切れるまで同じコードを再度交換できます。まず、Claude Consoleで以下を確認してください:

確認事項場所対処
アプリにオペレーターサービスアカウントがあるアプリのClient authenticationタブのOperator service account1つ選択してSaveをクリックします。設定方法はステップ3で説明しています。
アプリのワークスペースが存在し、アーカイブされていないアプリを設定するワークスペースを選択します。アプリにワークスペースがない間も、交換はunauthorized_clientで拒否されます。

保存したサービスアカウントがauth.claude.comに反映されるまで1〜2分かかることがあるため、交換が再び拒否された場合は、それくらい待ってから再試行してください。それまでにコードの有効期限が切れた場合は、ユーザーに再度承認してもらってください(ステップ5から8)。接続のトークンについてerror_descriptionが示す原因については、トークンを保存するとトークンをリフレッシュするを参照してください。

それ以外の場合は、Anthropicのアカウントチームにお問い合わせください。サービスアカウントがもう存在しないとConsoleに表示される場合も同様です。

アプリを公開する

アプリが公開されるまでは、アプリのTest usersリストに含まれるユーザーのみがアプリをリンクできるため、顧客はリンクできません。アプリを公開するには、Claude ConsoleのアプリのページでPublish appをクリックします。ダイアログボックスが開きます。

  • 組織が請求書払いの場合は、そのダイアログボックスで確認するとすぐにアプリが公開されます。
  • それ以外の場合は、まずそのダイアログボックスでアプリのドメインを管理していることを証明し、その後Anthropicがアプリを審査します。

ドメインの証明: ドメインとは、アプリのホームページのドメインです。すべてのリダイレクトURIは、localhost、127.0.0.1、または[::1]上のものを除き、そのドメインまたはそのサブドメイン上にある必要があります。証明にはDNS TXTレコードを使用します。DNSの変更には最大48時間かかることがあるため、顧客にリンクしてもらう必要が生じる前に開始してください。組織がホームページとそれらのリダイレクトURIをカバーするドメインをすでに証明している場合、ダイアログボックスでは証明がスキップされます。証明済みのドメインは、そのサブドメインもカバーします。

確認はダイアログボックスの最後のステップで行います。そのステップにLinked Billing Termsに同意するためのチェックボックスが表示された場合は、それを選択してください。次に、ダイアログボックスでPublish appをクリックします。

審査: 審査中、ConsoleでのアプリのステータスはIn reviewと表示されます。Anthropicが承認するとアプリが公開されます。Anthropicが承認しない場合、ステータスはNot approvedと表示され、自分でアプリを再度公開することはできません。この決定について問い合わせるには、サポートにお問い合わせください。

組織が請求書払いでない限り、公開済みのアプリの名前、ロゴ、ホームページ、またはリダイレクトURIを変更すると、アプリは審査に戻ります。すでにリンクしている顧客はリンクされたままで、保存した上限も維持されます。Anthropicが変更を承認するまでは、Test usersリストに含まれるユーザーのみがアプリをリンクできます。

Claudeへの呼び出しを更新する

リンク済みの顧客に対する/v1/messagesおよび/v1/chat/completionsへの各呼び出しで、anthropic-user-profile-idヘッダーを送信します。顧客に請求するリクエストでは、ヘッダーの値は、その顧客の接続を保持しているユーザープロファイルのIDです。billing_policyを設定する呼び出しでは、user-profiles-billing-2026-10-01ベータヘッダーも送信する必要があります。

リンク済みの顧客に対する各リクエストは、顧客またはあなたのいずれかに請求され、どちらにするかはリクエストごとに選択します。以下の例で両方を示します。

接続ごとのOAuthトークンでは、顧客のリクエストを認証する別の方法、つまりその顧客にのみ請求できるアクセストークンについて説明しています。/v1/messagesおよび/v1/chat/completionsでは、このようなトークンを使用したリクエストをあなたに請求することはできません。billing_policyやanthropic-user-profile-idヘッダーがなくても、それらが任意である場合は、そのリクエストはその顧客に請求されます。接続のアクセストークンでClaudeを呼び出すの注記を参照してください。リクエストが別のユーザープロファイルを指定しているか、bill_to: "self"を設定している場合は拒否されます。あなたが支払うリクエストには、このトークンを決して使用しないでください。

顧客が支払う場合

リクエストボディにbill_to: "user_profile"を指定したbilling_policyを追加し、請求ベータヘッダーとプロファイルIDヘッダーを送信します。

bill_to: "user_profile"は、顧客の指示によって行うリクエスト、つまり顧客とそのユーザーがあなたの製品内で発生させるClaudeの使用量に対してのみ設定してください。テスト、評価、または他の顧客のための作業など、あなた自身の使用量を顧客に請求しないでください。Claude APIはこれを確認できないため、これはあなたの責任となります。

def message_billed_to_user(user_profile_id: str, prompt: str) -> BetaMessage:
    return client.beta.messages.create(
        model="claude-opus-5-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}],
        betas=[BILLING_BETA],
        extra_headers={"anthropic-user-profile-id": user_profile_id},
        extra_body={
            "billing_policy": {"type": "billing_policy", "bill_to": "user_profile"}
        },
    )

リクエストが拒否された場合は、想定されるエラーを参照してください。

あなたが支払う場合

あなた自身が支払うには、billing_policyを完全に省略する(この場合、請求ベータヘッダーは任意です)か:

def message_billed_to_you(user_profile_id: str, prompt: str) -> Message:
    return client.messages.create(
        model="claude-opus-5-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}],
        user_profile_id=user_profile_id,
    )

またはbill_to: "self"を使用します:

def message_billed_to_self(user_profile_id: str, prompt: str) -> BetaMessage:
    return client.beta.messages.create(
        model="claude-opus-5-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": prompt}],
        betas=[BILLING_BETA],
        extra_headers={"anthropic-user-profile-id": user_profile_id},
        extra_body={"billing_policy": {"type": "billing_policy", "bill_to": "self"}},
    )

接続ごとのOAuthトークン

バックエンドは、アプリのオペレーターサービスアカウント(ステップ3)としてClaude APIを呼び出します。デフォルトでは、そのサービスアカウントとして認証された任意のリクエストが、ユーザープロファイルIDヘッダーを渡し、Messages APIリクエストにbill_toを含めることで、リンク済みのすべての顧客に請求できます。このデフォルトを「operator-only tokenless authentication」(オペレーターのみのトークンレス認証)と呼びます。

製品のシングルテナントデプロイメントや、顧客が管理するサンドボックス環境に対応するために、オペレーターのみのトークンレス認証を使用する代わりに、接続にバインドされたOAuthアクセストークンとリフレッシュトークンを取得できます。

各接続について、ステップ8のコード交換はその接続独自のアクセストークンを返します。このトークンはオペレーターサービスアカウントとして認証しますが、請求できるのはその接続の顧客のみです。有効期限は1時間以内です。

各接続を個別に認証するには:

  • オフラインアクセスを使用する。 アプリのOffline accessを有効にし、ステップ5でoffline_accessをリクエストします。これにより、各接続はリフレッシュトークンも取得し、バックエンドはそれを使用して新しいアクセストークンをリクエストします。これがない場合、新しいアクセストークンを得るには顧客が再度承認する必要があります。同じscopeでステップ5から8を再度実行してください。
  • デフォルトのワークスペースを設定する。 これらのトークンを使用したリクエストを実行するワークスペースを、組織内で選択します。
  • 必要に応じて、オペレーターのみのトークンレス認証を無効にする。 デフォルトでは、顧客のアクセストークンの有効期限が切れた後でも、オペレーターサービスアカウントとして(ユーザープロファイルヘッダーとbill_toを渡すことで)リンク済みの顧客に請求できます。オペレーターのみの認証をオフにした後は、顧客に請求するすべてのリクエストがその顧客のアクセストークンで認証する必要があります。
  • billing:attributionを使用する。 接続に独自のトークンを与えるのはこのスコープのみです。非推奨のorg:billing_attributionと同様に、引き続きオペレーターサービスアカウントとしてリンク済みの顧客に請求できます。請求接続のスコープを参照してください。

アプリを設定する

接続のアクセストークンを使用したリクエストは、組織内の1つのワークスペースで実行されます。これらのトークンを使用しない場合でも、すべてのアプリにワークスペースが必要です。アプリにワークスペースがない間は、ステップ8のコード交換はunauthorized_clientで拒否されます。

管理者のロールを持つ組織のメンバーが、ConsoleでアプリのClient authenticationタブを開きます。オペレーターサービスアカウントの下にあるDefault workspace for platform auth mode OAuth tokens(アプリのconnection_token_workspace_id設定)を見つけ、Choose workspaceをクリックします。オペレーターサービスアカウント(ステップ3)がメンバーであるワークスペースを選択します。ワークスペースはアーカイブされていてはいけません。

リフレッシュトークンを取得するには、アプリのPermissionsタブでOffline accessを有効にします。アプリのスコープへの変更がauth.claude.comに反映されるまでには数分かかります。

請求接続のスコープ

ステップ5では、scopeとしてbilling:attributionを送信します。リフレッシュトークンも取得するには、billing:attribution offline_accessを送信します。

すでにリンク済みの顧客のスコープを変更するには(たとえばoffline_accessを追加する場合)、顧客の既存のユーザープロファイルと新しいscopeを使用してステップ5から8を再度実行します。先にリンクを解除する必要はありません。コードの交換によって新しいconnection_idが返され、新しい接続が以前の接続を置き換えます。ステップ8の注記を参照してください。

アプリは、billing:attributionと非推奨のorg:billing_attributionを同時に持つことができます。billing:attributionは、アプリのPermissionsタブのBillingの下で追加します。そこでorg:billing_attributionを削除すると、再度追加することはできません。顧客がorg:billing_attributionで承認した接続は、接続が終了するか、あなたがオペレーターのみの認証をオフにするまで、オペレーターサービスアカウントを通じて請求を続けます。

トークンを保存する

コードの交換でトークンが返されるのは1回のみであるため、ステップ8でトークンを保存してください。レスポンスには、access_token、expires_in(最大1時間、秒単位)、およびconnection_idが含まれます。顧客がoffline_accessを承認した場合は、refresh_tokenとrefresh_token_expires_inも含まれます。リフレッシュトークンの有効期間は最大1年で、リフレッシュしてもその期間は延長されません。期限が過ぎたら、顧客を再度リンクしてください。

トークンとその有効期限は、リフレッシュを行うサービスのみが読み取れるシークレットストアに保存してください。

交換がunauthorized_clientで拒否された場合、error_descriptionには、ワークスペースが存在しない、またはアーカイブされているなどの原因が示されます。コードは消費されていません。原因を修正し、期限が切れる前に同じコードを再度送信してください。

接続のアクセストークンでClaudeを呼び出す

接続のアクセストークンを、オペレーターサービスアカウント自身の認証情報の代わりに、Authorizationヘッダーのベアラートークンとして送信します。x-api-keyヘッダーは送信しないでください。Anthropic SDKでは、トークンをauth_tokenとして渡すか、ANTHROPIC_AUTH_TOKEN環境変数を設定します。

/v1/messagesと/v1/chat/completionsでは、リクエストはその接続の顧客に請求されます。anthropic-user-profile-idヘッダーとbilling_policyは任意です。請求ベータヘッダーが必要なのは、billing_policyを使用する場合のみです。

これら2つのエンドポイントでは、このトークンを使用してあなたが支払うリクエストを送信することはできません。このトークンは、これら2つのエンドポイント、/v1/messages/count_tokens、およびModelsエンドポイントでのみ使用してください。その他のすべてのリクエストと、あなたが支払うすべてのリクエストは、自身のバックエンドから、オペレーターサービスアカウントとして送信してください。これには、顧客に請求できない課金対象のコード実行機能を使用するリクエストも含まれます。

Claude APIは以下のリクエストを拒否します:

  • 400 invalid_request_error(エラーコードなし):リクエストが別のユーザープロファイルを指定したか、bill_to: "self"を設定しました。
  • 403 permission_error(エラーコードなし):リクエストがMessage Batchesエンドポイントに送信されました。
  • 401 authentication_error:トークンの有効期限が切れた、リフレッシュによって置き換えられた、またはその接続が終了しました。接続が終了した後は、レスポンスが403 user_profile_not_billableになることもあります。

トークンをリフレッシュする

接続のアクセストークンを更新するには、そのリフレッシュトークンを、アプリのクライアント認証とともにトークンエンドポイントhttps://auth.claude.com/v1/oauth/tokenに送信します。scopeパラメータは送信しないでください。

connection_locks: defaultdict[str, threading.Lock] = defaultdict(threading.Lock)


def error_body(response: httpx.Response) -> dict:
    try:
        body = response.json()
    except ValueError:
        return {}
    return body if isinstance(body, dict) else {}


def is_lost(response: httpx.Response) -> bool:
    """True for a 5xx response that can follow a refresh that took effect."""
    if response.status_code < 500:
        return False
    # retry-afterヘッダー付きのClaude API形式の503は、拒否応答であり
    # リフレッシュトークンを使用しません。その他の5xx応答はすべて失われたものとみなします。
    paused = (
        response.status_code == 503
        and error_body(response).get("type") == "error"
        and "retry-after" in response.headers
    )
    return not paused


def hold_error(connection_id: str, reason: str) -> RefreshOnHold:
    return RefreshOnHold(
        f"Connection {connection_id} is on hold. {reason} Don't send its refresh token"
        ' again: that can end the connection. See "Link a customer again" in the'
        " Linked billing guide."
    )


def refresh_connection(connection_id: str, *, force: bool = False) -> tuple[str, int]:
    """Refreshes the connection if its access token is close to its expiry.

    Returns the current access token and its expiry time in Unix seconds. Call
    this from your schedule, and pass force=True to refresh a token that isn't
    close to its expiry. Raises RefreshOnHold when the refresh token can't be sent
    again, now and on every later call, and httpx.HTTPStatusError for a refusal
    that keeps the refresh token. After RefreshOnHold for a lost refresh, pause
    your schedule. Resume with one connection, and resume the others only after
    that refresh succeeds or gets a 4xx.
    """
    # このロックは1プロセス内でのみ機能します。サービスにレプリカがある場合は、
    # すべてのレプリカで共有するロックを使用してください。
    with connection_locks[connection_id]:
        tokens = load_tokens(connection_id)
        if tokens.on_hold:
            raise hold_error(
                connection_id, "An earlier refresh might have used its refresh token."
            )
        if not force and tokens.expires_at - time.time() > REFRESH_MARGIN_SECONDS:
            return tokens.access_token, tokens.expires_at  # not close to expiry
        request = {
            "grant_type": "refresh_token",
            "refresh_token": tokens.refresh_token,
            "client_id": CLIENT_ID,
            "client_assertion_type": JWT_BEARER,
            "client_assertion": client_assertion(),
        }
        url = f"{AUTH}/v1/oauth/token"
        # リフレッシュトークンがこのプロセスを離れる前に、接続を保留状態にします。
        # 新しいトークンの保存前にプロセスが停止した場合、保留状態は残ります。
        save_tokens(connection_id, replace(tokens, on_hold=True))
        issued_at = int(time.time())
        started = time.monotonic()
        # httpxは自動でリトライしません。リトライを追加しないでください。遅れたリトライは
        # 接続を終了させます。
        try:
            response = httpx.post(url, json=request, timeout=REQUEST_TIMEOUT)
            lost = is_lost(response)
        except (httpx.ConnectError, httpx.ConnectTimeout):
            # 接続は確立されなかったため、リフレッシュトークンはこのプロセスから出ていません。
            save_tokens(connection_id, tokens)
            raise
        except httpx.TransportError:
            lost = True
        if lost:
            # 1回目のリクエストがリフレッシュトークンを使用した可能性があります。2回目のリクエストは
            # 上記の制限内でのみ安全なため、すぐに1回送るか、まったく
            # 送らないかのどちらかにします。
            if time.monotonic() - started > SECOND_REQUEST_DEADLINE_SECONDS:
                raise hold_error(connection_id, "A refresh got no usable answer.")
            try:
                response = httpx.post(url, json=request, timeout=REQUEST_TIMEOUT)
            except httpx.TransportError:
                raise hold_error(
                    connection_id, "Two refreshes got no answer."
                ) from None
            if response.status_code != 200:
                # 新しいトークン以外の応答の後は、
                # 1回目のリクエストが反映されたか判断できず、後からのリクエストは安全ではありません。
                raise hold_error(connection_id, "The second refresh failed.")
        if error_body(response).get("error") == "invalid_grant":
            # 期限切れ、使用済み、または接続が終了しています。再送すると
            # 接続が終了する可能性があります。
            raise hold_error(connection_id, "The refresh returned invalid_grant.")
        if response.status_code != 200:
            # リフレッシュトークンを保持したままの拒否応答なので、保留を解除します。
            save_tokens(connection_id, tokens)
            response.raise_for_status()
        body = response.json()
        tokens = ConnectionTokens(
            refresh_token=body["refresh_token"],
            access_token=body["access_token"],
            expires_at=issued_at + body["expires_in"],
            refresh_expires_at=issued_at + body["refresh_token_expires_in"],
        )
        # 書き込みに失敗した場合は書き込みを再試行します。リフレッシュは再実行しないでください。
        for attempt in range(5):
            try:
                save_tokens(connection_id, tokens)
                return tokens.access_token, tokens.expires_at
            except OSError:  # your secret store's error type
                if attempt < 4:
                    time.sleep(2**attempt)
        # 新しいトークンはこのプロセス内にしか存在せず、保存済みのリフレッシュトークンは
        # 使用済みです。保存済みレコードはまだ保留状態です。エラーは新しいトークンを保持するため、
        # シークレットストアが復旧したときに呼び出し元が保存できます。
        error = hold_error(
            connection_id,
            "The refresh succeeded, but the new tokens could not be saved.",
        )
        error.new_tokens = tokens
        raise error

レスポンスには、新しいaccess_tokenと新しいrefresh_tokenが含まれます。送信したリフレッシュトークンは置き換えられます。以下の失敗のリストで示す場合を除き、再度送信しないでください。以前のアクセストークンは数分以内に使用できなくなります。例で呼び出している関数は、OAuthトークンのコードスニペットの初期化で定義されています。

  • 新しいアクセストークンを使用する前に、新しいリフレッシュトークンを保存してください。
  • 各接続のトークンのリフレッシュは、1つのサービスから、一度に1回ずつ行ってください。サービスにレプリカがある場合は、すべてのレプリカが共有するロックを使用してください。使用済みのリフレッシュトークンが最初の使用から30秒以上経ってから再度届くと、接続が終了します。すべてのトークンが取り消され、顧客はUnlinkedと表示され、顧客が再度リンクするまで、どの認証情報でも顧客に請求できなくなります。
  • HTTPクライアントおよびプロキシで、リフレッシュリクエストの自動再試行をオフにしてください。

リフレッシュトークンを使用した最初のリクエストが失敗した場合:

  • リクエストが接続できなかった:リフレッシュトークンは送信されていません。後で再試行してください。
  • 接続が切断された、またはこのリストの503以外の5xxレスポンスが返された:リクエストが反映されたかどうかを判断できないため、同じリフレッシュトークンをもう一度だけ送信してください。
    1. 直ちに送信してください。ただし、最初のリクエストを送信してから30秒未満の場合に限ります。
    2. 新しいトークンが返された場合は、それを保存し、それのみを使用してください。最初のリクエストが反映されていた場合、あなたに届かなかったそのトークンは取り消されます。
    3. それ以外が返された、応答がなかった、または30秒が経過した場合は、そのリフレッシュトークンを再度送信しないでください。その接続のリフレッシュを停止し、顧客を再度リンクしてください。
  • タイムアウトした:リクエストがまだ実行中である可能性があります。そのリフレッシュトークンを再度送信しないでください。その接続のリフレッシュを停止し、顧客を再度リンクしてください。
  • 429、またはretry-afterヘッダーがあり、ボディの最上位に"type": "error"がある503:何も取り消されていません。少なくともヘッダーが示す時間だけ待ってから、同じリフレッシュトークンを再度送信してください。
  • unauthorized_clientまたはinvalid_client:何も取り消されていません。error_descriptionには、ワークスペースが存在しない、アプリにoffline_accessが登録されなくなった、クライアントアサーションが失敗したなどの原因が示されます。それを修正し、同じリフレッシュトークンを再度送信してください。
  • invalid_scope:リクエストがscopeパラメータを送信したか、アプリにbilling:attributionが登録されなくなりました。何も取り消されていません。原因を修正し、同じリフレッシュトークンを再度送信してください。
  • invalid_grant:リフレッシュトークンの有効期限が切れた、またはすでに使用された、接続が終了した、あるいは顧客の組織が停止されています。その接続のリフレッシュを停止し、顧客を再度リンクするに従ってください。これは停止の確認から始まります。

接続の切断、5xxレスポンス、またはタイムアウトによって接続のリフレッシュを停止した場合は、他の接続のリフレッシュも一時停止してください。再開する際は、まず1つの接続をリフレッシュし、そのリフレッシュが成功するか4xxレスポンスを受け取った後にのみ、他の接続を再開してください。

サンドボックスでエージェントを実行する

サンドボックスにはアクセストークンのみを渡し、リフレッシュトークンは決して渡さないでください。リフレッシュはバックエンドが行い、新しいアクセストークンをその都度サンドボックスに送信します。バックエンドは、サンドボックスがどの顧客にサービスを提供するかを、ポッドのアイデンティティなどのサンドボックス自身のアイデンティティから判断し、サンドボックスが送信する値からは決して判断しません。サンドボックスにはその顧客のトークンのみを送信します。サンドボックスが、フェデレーションルールまたはアプリのクライアント認証のいずれかに一致するJWTを取得できてはなりません。マウントされたアイデンティティトークンを与えず、クラウドのメタデータサーバーへのアクセスも与えないでください。

Claude Code、Claude Agent SDK、およびAnthropic SDKは、設定プロファイル内の認証情報ファイルからトークンを読み取ることができます(プロファイル設定ファイルを参照)。サンドボックス内に、このプロファイルを含む設定ディレクトリを作成します。client_idは追加しないでください。追加すると、SDKがトークンを自らリフレッシュしようとします。

configs/customer.json
{
  "version": "1.0",
  "authentication": {
    "type": "user_oauth"
  }
}

エージェントが起動する前と各リフレッシュの後に、アクセストークンを同じディレクトリ内のcredentials/customer.jsonとして書き込みます。expires_atはUnix秒での有効期限です。モード0600で新しいファイルを書き込み、それを古いファイルに上書きする形でリネームします:

credentials/customer.json
{
  "type": "oauth_token",
  "access_token": "sk-ant-oat01-...",
  "expires_at": 1793635200
}

ANTHROPIC_CONFIG_DIRを設定ディレクトリに、ANTHROPIC_PROFILEをcustomerに設定します。ANTHROPIC_API_KEY、ANTHROPIC_AUTH_TOKEN、CLAUDE_CODE_OAUTH_TOKEN、Claude CodeのapiKeyHelper設定など、サンドボックス内のその他の認証情報はすべて設定を解除してください。いずれもプロファイルより優先される可能性があるためです。エージェントは、expires_atの前の最後の2分間と、401レスポンスの後にファイルを再度読み取ります。

def write_credentials_file(
    config_dir: Path, profile: str, token: str, expires_at: int
) -> None:
    credentials_dir = config_dir / "credentials"
    credentials_dir.mkdir(mode=0o700, parents=True, exist_ok=True)
    body = {"type": "oauth_token", "access_token": token, "expires_at": expires_at}
    # 完成したファイルをリネームして配置し、エージェントが不完全なファイルを読まないようにします。
    # mkstempは現在のユーザーを所有者としてモード0600を設定するため、これは
    # エージェントのユーザーとして実行してください。
    handle, temporary_path = tempfile.mkstemp(dir=credentials_dir)
    with os.fdopen(handle, "w") as temporary_file:
        json.dump(body, temporary_file)
    os.replace(temporary_path, credentials_dir / f"{profile}.json")

顧客を再度リンクする

以下の場合は、顧客を再度リンクしてください:

  • リフレッシュがinvalid_grantを返した。
  • リフレッシュトークンを紛失した、または漏洩した。
  • billing:attribution offline_accessに対するステップ8のレスポンスを失った、またはそのような接続に対してステップ8がinvalid_grantを返した。
  • リフレッシュトークンの有効期限が近づいている。

以下の手順に従ってください:

  1. User profilesページで、顧客がLinkedと表示されているかどうかを確認します。invalid_grantの後は、まず顧客の組織が停止されているかどうかをAnthropicのアカウントチームに確認してください。停止が解除されると、保持しているリフレッシュトークンは再び機能します。すべての接続が同時にinvalid_grantを返す場合は、誰かのリンクを解除する前に、アーカイブされたワークスペースなど、あなたの側の原因を探してください。
  2. 顧客がLinkedと表示されている場合は、顧客のリンクを解除するの説明に従ってリンクを解除します。リンクを解除すると、接続のトークンが取り消されます。承認するまで接続を通じた請求が停止するため、顧客の組織の管理者が承認する準備ができているときに行ってください。
  3. 顧客の既存のユーザープロファイルを使用して、ステップ5から8を再度実行します。新しい接続IDと新しいトークンを、以前のものの代わりに保存します。

オペレーターのみの認証をオフにする

オペレーターサービスアカウントとしてのみ認証するリクエストが顧客に請求されないようにするには、Disable operator-only tokenless authentication(アプリのdisable_operator_only_auth設定)をオンにします。これは、アプリのClient authenticationタブのオペレーターサービスアカウントの下にあります。アプリには、billing:attributionおよびoffline_accessスコープと、OAuthトークン用のワークスペースが必要です。オンにする前に、リンク済みのすべての顧客がbilling:attribution offline_accessを承認していること、および顧客のアクセストークンを使用したリクエストが機能することを確認してください。オンの間は、billing:attribution接続のアクセストークンのみが、その接続の顧客に請求できます。サービスアカウントのみとして認証し、bill_to: "user_profile"を設定したリクエストは、403 user_profile_not_billableで拒否されます。顧客は引き続きLinkedと表示されるため、ログでこのエラーを監視してください。サービスアカウントは引き続き、ユーザープロファイルを管理し、あなたが支払うリクエストを送信できます。この設定は再度オフにできます。

OAuthトークンのコードスニペットの初期化

このセクションの例は、以下の共通のセットアップを使用します。以下を定義します:

  • インポート(httpxパッケージを含む)
  • アプリのクライアントIDとクライアントアサーションのタイプ
  • ConnectionTokens。接続のトークン、その有効期限、およびon_holdマークを保持します
  • RefreshOnHold。リフレッシュトークンを再度送信してはならない場合にrefresh_connection()が発生させるエラーです。そのリフレッシュトークンはすでに使用されている可能性があるか、トークンエンドポイントがinvalid_grantを返しました。保存されたトークンのon_holdを解除するまで(たとえば停止が解除された後など)、refresh_connection()は以降のすべての呼び出しでもこのエラーを発生させます。リフレッシュが成功し、シークレットストアへの書き込みのみが拒否された場合、そのnew_tokensに保存すべきトークンが保持されます。
  • client_assertion()。ANTHROPIC_IDENTITY_TOKEN_FILEが指定するファイルから、アイデンティティプロバイダーのJWTを読み取ります。JWTのaudクレームは、アプリのクライアント認証設定のオーディエンスである必要があります。
  • load_tokens()とsave_tokens()。自身のシークレットストア向けにあなたが記述します
import json
import os
import tempfile
import threading
import time
from collections import defaultdict
from dataclasses import dataclass, field, replace
from pathlib import Path

import httpx

AUTH = "https://auth.claude.com"
# OAuthアプリを登録した後、platform.claude.comからコピーします。
CLIENT_ID = "YOUR_CLIENT_ID"
JWT_BEARER = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer"
REFRESH_MARGIN_SECONDS = 600
# ここでタイムアウトしたリフレッシュは新しいトークンを失うため、応答には10秒を確保します。
# 応答を待ちます。接続できない場合は2秒以内に失敗します。
REQUEST_TIMEOUT = httpx.Timeout(10, connect=2)
# 2回目のリクエストは1回目の直後のこの時間内に開始するか、まったく送らないでください。
# ページでは30秒としていますが、REQUEST_TIMEOUTの読み取りタイムアウト未満に保ちます。
# タイムアウトしたリクエストは再送してはいけません。
SECOND_REQUEST_DEADLINE_SECONDS = 4


@dataclass
class ConnectionTokens:
    refresh_token: str = field(repr=False)
    access_token: str = field(repr=False)
    expires_at: int  # the access token's expiry time, in Unix seconds
    refresh_expires_at: int  # the refresh token's expiry time, in Unix seconds
    # True: リフレッシュトークンが使用された可能性があります。再送しないでください。
    on_hold: bool = False


class RefreshOnHold(Exception):
    """The refresh token might have been used, so a person decides what to do next.

    Don't catch this to try again. If new_tokens is set, the refresh succeeded and
    only the write failed: store those tokens.
    """

    new_tokens: ConnectionTokens | None = None


def client_assertion() -> str:
    """Reads your identity provider's JWT on every call, because its file rotates."""
    return Path(os.environ["ANTHROPIC_IDENTITY_TOKEN_FILE"]).read_text().strip()


def load_tokens(connection_id: str) -> ConnectionTokens:
    """Reads the connection's newest tokens from your secret store."""
    raise NotImplementedError("Read the tokens from your secret store.")


def save_tokens(connection_id: str, tokens: ConnectionTokens) -> None:
    """Writes the connection's newest tokens to your secret store."""
    raise NotImplementedError("Write the tokens to your secret store.")

接続の管理

Consoleで顧客を表示する

OAuthアプリページに加えて、ConsoleのUser profilesページですべてのユーザープロファイルを表示できます。そのリストと各ユーザープロファイルの詳細ページで、Your spendは、そのユーザープロファイルのリクエストに対するあなた自身のコストです。これは、Anthropicがクレジットを適用する前のコストです。これらのページでは接続を「リンク」と呼びます。接続がアクティブなユーザープロファイルにはLinked、接続が終了したユーザープロファイルにはUnlinkedと表示されます。

ユーザープロファイルをクリックすると、過去7日間、28日間、または90日間の使用量のより詳細なビューが表示されます。

各顧客の使用量を監視する

Claude ConsoleとUsage and Cost Analytics APIはどちらも、ユーザープロファイルごとの使用量を報告します。どちらも、あなたが支払うリクエストと顧客が支払うリクエストの両方をカウントします。どちらも、顧客が支払った金額や顧客の料金は表示しません。

Consoleでは、User profilesページに、過去28日間の各ユーザープロファイルのRequests、Tokens、およびYour spendが一覧表示されます。顧客が支払うリクエストは、プロファイルのRequestsとTokensに加算され、Your spendには何も加算されません。

APIは、org:adminスコープを持つOAuthアクセストークンやAdmin APIキーなどのAdmin APIの認証情報で呼び出してください。オペレーターサービスアカウント(ステップ3)は使用しないでください。そのフェデレーションルールは、デフォルトでorg:adminではなくworkspace:developerを付与します。org:adminスコープはAdmin API全体を対象とするため、オペレーターサービスアカウントには追加しないでください。

APIを通じてユーザープロファイルごとに報告するには、その使用量エンドポイントまたはコストエンドポイントを呼び出します。ユーザープロファイルごとに1行を取得するには、user_profile_idのみでグループ化し、time_bucket_widthを省略します。行が返されるのは、リクエストした期間内に使用量があるユーザープロファイルのみです。さらに1行、user_profile_idがnullの行があります。この行には、プロファイルを指定しなかった使用量と、コード実行コンテナの時間など、リクエストの外で計測される使用量が含まれます。

コストエンドポイントでは、顧客が支払うリクエストは、amountに0を、list_amountにその定価を加算します。amountフィールドはYour spendと同じ尺度です。APIには、誰が支払ったかを示すフィールド、フィルター、またはgroup_by[]の値はありません。amountが0でlist_amountが0より大きい行は、通常、その行のすべてのリクエストを顧客が支払ったことを意味します。

これらの数値を使用して、あなたが選択した金額で顧客の使用を停止しないでください。ConsoleもAPIもリアルタイムでは報告しません。Consoleの数値は約1時間に1回更新され、リクエストが表示されるまでに数時間かかることがあります。APIの遅延については、データの鮮度を参照してください。顧客自身の制限がどのように機能するかについては、支出上限を参照してください。

顧客のリンクを解除する

Consoleで顧客のリンクを解除するには、User profilesページのリスト、またはユーザープロファイルの詳細ページ右上にあるUnlinkボタンを使用します。

バックエンドから顧客のリンクを解除するには、ステップ8で保存した接続IDを、コード交換と同じクライアント認証を使用して取り消しエンドポイントに送信します。代わりにユーザープロファイルで接続を指定するには、connection_idの代わりにuser_profile_idを送信します。

def revoke_connection(connection_id: str) -> list[str]:
    response = httpx.post(
        f"{AUTH}/v1/oauth/revoke",
        json={
            "connection_id": connection_id,
            "client_id": CLIENT_ID,
            "client_assertion_type": JWT_BEARER,
            "client_assertion": client_assertion(),
        },
    )
    response.raise_for_status()
    # このリクエストで終了した接続の ID。接続がすでに終了していた場合、
    # または ID が不明な場合、リストは空になります。
    return response.json()["revoked_connection_ids"]

auth.claude.comは、HTTP 200と、このリクエストによって終了した接続のIDであるrevoked_connection_idsを返します。接続がすでに終了している場合、リストは空になるため、connection_idを送信するリクエストは安全に繰り返すことができます。IDが不明な場合もリストは空になるため、空のリストは接続が存在したことを証明するものではありません。その他のパラメータについては取り消しを、エラーについては取り消しエンドポイントからのエラーを参照してください。

接続が終了すると、ユーザープロファイルはUnlinkedと表示され、この顧客に対してbill_to: "user_profile"を設定したリクエストはuser_profile_not_billableを受け取ります。bill_to: "self"を指定することで、引き続き自己負担で顧客にサービスを提供できます。顧客側の表示についてはリンク後を、どの方法でリンクを解除すると顧客にメールが送信されるかについてはリンクとリンク解除に関するメールを参照してください。

顧客を別のClaude組織にリンクする

顧客のユーザープロファイルを別のClaude組織にリンクするには、顧客のリンクを解除してから、再度リンクします。

リンクを解除した後は、この顧客に請求するリクエストは拒否されます。これは、ユーザーが別の組織について承認し、あなたがステップ8でコードを交換するまで続きます。そのユーザーが承認する準備ができたら、以下の手順に従ってください:

  1. 顧客がすでに自身のLinked platformsページでアプリのリンクを解除している場合は、このステップをスキップしてください。それ以外の場合は、顧客のリンクを解除するの説明に従って顧客のリンクを解除します。その後、ユーザープロファイルはUser profilesページでUnlinkedと表示されます。
  2. 同じユーザープロファイルを使用して、ステップ5から8を再度実行します。ステップ7では、ユーザーは別の組織で管理者または請求のロールを持つアカウントが必要です。ユーザーにその組織について承認してもらってください。
  3. 新しい接続IDを以前のものの代わりに保存します。接続のトークンを使用している場合は、新しいトークンについても同様にしてください。

顧客のリンクが解除されるまで、承認ページでは、すでにリンクされている組織についてのみ承認できます。

支出上限は1つの顧客組織とあなたのアプリに属するため、最初の組織の上限は引き継がれません。ルールについては支出上限を参照してください。

想定されるエラー

リクエストでbill_to: "user_profile"を設定した場合、Anthropicは顧客に請求するか、リクエストを拒否するかのいずれかです。代わりにあなたに暗黙的に請求することはありません。/v1/messagesでは、以下のリストのコードはerror.details.error_codeに含まれます。/v1/chat/completionsでは、コードなしで、同じHTTPステータスとメッセージがOpenAI形式で返されます:

  • 403 permission_error, user_profile_not_billable:Anthropicはこのリクエストについてこの顧客に請求できず、レスポンスには理由は示されません。新しい接続後の最初の10秒間を除き、再試行できません。顧客に再度リンクするよう依頼する前に、user_profile_not_billableの原因を参照してください。再リンクで解決するのはその一部のみです。bill_to: "self"を指定して再送信することで、引き続き自己負担で顧客にサービスを提供できます。Anthropic SDKでは、403ステータスのエラークラスであるPermissionDeniedErrorによってuser_profile_not_billableを処理します。これは他の403エラーにも一致するため、エラーコードも確認してください。
  • 402 billing_error, linked_organization_billing_unavailable:Anthropicは現在、顧客の組織に請求できません(たとえば、組織が停止されている、またはClaudeが応答を開始した後にクレジットが尽きた場合)。レスポンスには理由は示されません。リクエストが届いた時点でクレジットがない顧客には、代わりにlinked_organization_spend_limit_reachedが返されます。再試行できません。顧客にClaude Platformアカウントを確認するよう伝えてください。bill_to: "self"を指定して再送信することで、引き続き自己負担で顧客にサービスを提供できます。
  • 402 billing_error, linked_organization_spend_limit_reached:顧客の組織が自ら設定した支出制限に達しました。これは、アプリに適用される支出上限、または組織全体の月間支出制限のいずれかです。組織にリクエストの支払いに充てられるクレジットがない場合にも、Claude APIは同じコードを送信します。レスポンスにはどちらであるかは示されません。リクエストはClaudeが応答を開始する前に拒否されました。再試行できません。bill_to: "self"を指定して再送信することで、引き続き自己負担で顧客にサービスを提供できます。Claude Consoleで以下を確認するよう顧客に依頼してください:
    • アプリの支出上限: 顧客は、Linked platformsにあるアプリのページで支出上限を設定または引き上げることができます。そこで設定した上限は、すべてのリンク済みプラットフォームに対して設定したデフォルトの上限を置き換えます。
    • 組織の月間支出上限: 支出上限で引き上げることができます。
    • クレジット残高: 請求ページで、クレジット残高を確認し、クレジットを購入できます。一部のクレジットはこれらのリクエストの支払いに使用できません。支払いに使用できるクレジットを参照してください。
  • 503 overloaded_error:Anthropicは現時点で顧客に請求できるかどうかを確認できませんでした。バックオフを用いて再試行し、retry-afterヘッダーに従ってください。リクエストは処理されておらず、請求もされていません。
  • 400 invalid_request_error, user_profile_required:anthropic-user-profile-idヘッダーなしでbill_to: "user_profile"を設定しました。このようなリクエストには、接続のアクセストークンを使用し、かつヘッダーが任意である場合を除き、ヘッダーが必要です。ヘッダーが任意かどうかを確認するには、接続のアクセストークンでClaudeを呼び出すの注記を参照してください。
  • 400 invalid_request_error(エラーコードなし):anthropic-user-profile-idヘッダーに、形式が不正なID、またはあなたの組織のユーザープロファイルではないIDが含まれています。
  • 400 invalid_request_error(エラーコードなし):リクエストが接続のアクセストークンで認証され、bill_to: "self"を設定したか、トークンが限定されているユーザープロファイル以外のユーザープロファイルを指定しました。接続のアクセストークンでClaudeを呼び出すを参照してください。

/v1/messagesと/v1/chat/completionsでは、接続のアクセストークンを使用してあなたが支払うリクエストを送信することはできません。拒否されたリクエストをbill_to: "self"を指定して再送信するには、自身のバックエンドから、オペレーターサービスアカウント自身の認証情報で認証してください。トークン自体に対する拒否については、接続のアクセストークンでClaudeを呼び出すに記載されています。

成功したレスポンスには誰に請求されたかが示されないため、どのリクエストをbill_to: "user_profile"で送信したかを独自に記録しておいてください。

user_profile_not_billableの原因

以下の順に確認してください:

  • リクエスト。 リクエストは、OAuthアプリのオペレーターサービスアカウント(ステップ3)として認証する必要があります。接続のアクセストークンも、そのサービスアカウントとして認証します。それ以外の方法で認証したリクエストは拒否されます。たとえば、別のサービスアカウントや、そのサービスアカウントに紐付けられていないAPIキーです。anthropic-user-profile-idヘッダーが、リンクされていないあなたのプロファイルのいずれかを指定している場合、リクエストは拒否されます。認証情報またはヘッダーが誤っている場合は、リクエストを修正してください。新しい接続では解決しません。
  • 接続。 顧客がこのアプリを通じてリンクしていないか、接続が終了しています。顧客の組織またはあなたの組織の管理者が接続を終了したか、あなたのバックエンドが終了しました。終了した接続は、User profilesページでUnlinkedと表示されます。テストアプリを通じてのみリンクされたプロファイルは、本番アプリにはリンクされていません。顧客がリンクするまで、その顧客への請求を停止してください。接続のアクセストークンはその接続に限定されるため、顧客が再度リンクした後は、新しい接続のアクセストークンを使用してください。アプリでオペレーターのみの認証をオフにしている場合、顧客に請求できるのは、その顧客の接続のアクセストークンを使用する場合のみです。その場合、billing:attribution接続の有効なトークンを保持していない顧客は、Linkedと表示されていても、顧客を再度リンクするの説明に従って再度承認する必要があります。
  • 顧客の組織。 対象となる顧客である必要があります。これはあなたの側からは確認できないため、Anthropicのアカウントチームに問い合わせてください。

新しい接続は通常すぐに機能しますが、ステップ8の交換後、約10秒かかる場合があります。その10秒間にリクエストがuser_profile_not_billableで拒否された場合は、再度送信してください。それ以降は、待機しても再試行しても結果は変わりません。拒否された各リクエストについて、error.message全体とrequest-idレスポンスヘッダーをログに記録してください。接続がLinkedと表示されている顧客が引き続き拒否され、リクエストが正しい場合は、拒否された理由をAnthropicが調べられるよう、拒否されたリクエストのrequest-idをAnthropicのアカウントチームに送信してください。

顧客側の表示

リンク

ステップ6でアプリがユーザーをリダイレクトした後、ユーザーはauth.claude.comで承認します。ステップ7に承認ページの画面が一覧表示されています。各画面にはアプリの名前が表示され、Cancelボタンがあります。各画面でユーザーが行うことは次のとおりです:

  • Select an organization: ユーザーは、自身のClaude組織のうちどれをリンクするかを選択します。この画面は、ユーザーが組織を選択できる場合にのみ表示されます。
  • How billing works: ユーザーは画面を読み、Continueをクリックします。
  • Set a monthly spend limit: ユーザーは、あなたのアプリの上限を米ドルの整数単位で入力してContinueをクリックします。金額フィールドは空の状態で始まるため、ページがユーザーの代わりに上限を選択することはありません。Continue without a limitを選択すると新しい上限は保存されず、顧客が以前に保存した上限またはデフォルトが引き続き適用されます。ユーザーが入力する上限は、支出上限で説明されている支出上限です。アプリがテスト中の間は、この画面が異なります。アプリのテスト中を参照してください。
  • 最後の画面: この画面には、ユーザーが選択した上限を含め、あなたのアプリが実行できることが一覧表示されます。ユーザーはLink and authorizeをクリックします。

承認ページは、ブラウザでサインインしているClaudeアカウントを使用し、そのアカウントのClaude組織のみを提示します。これは、ユーザーが想定しているアカウントではない可能性があります(たとえば、仕事用ではなく個人用のアカウントなど)。アプリがアカウントを選択することはできません。OpenID Connectのパラメータprompt=select_accountとlogin_hintは、ページが使用するアカウントを変更しません。

リンク後

顧客は、Claude ConsoleのLinked platformsページで接続を管理します。顧客はいつでもアプリのリンクを解除できます。解除されても、Anthropicはあなたに通知しません。webhookイベントもメールも届きません。

顧客がリンクを解除した後、その顧客に請求するリクエストは403 user_profile_not_billableで拒否されます(user_profile_not_billableの原因を参照)。ConsoleのUser profilesページでは、その顧客のユーザープロファイルがUnlinkedと表示されます。再度リンクするには、顧客の既存のユーザープロファイルを使用してステップ5から8を再度実行してください。

リンクとリンク解除に関するメール

リンクとリンク解除に関するAnthropicのメールは、顧客の組織で管理者または請求のロールを持つメンバーに送信されます。各メールには、顧客のLinked platformsページへのリンクが含まれます。Anthropicがメールを送信するかどうかは、イベントによって異なります:

  • 顧客がアプリをリンクしたとき: あなたがステップ8でコードを交換した時点で、Anthropicはメールを送信します。コードが交換されなかった承認については、何も送信しません。また、顧客がまだリンクされている間にユーザーが再度承認した場合も、何も送信しません。
  • 顧客がアプリのリンクを解除したとき: Anthropicはメールを送信します。メールには、アプリのリンクを解除した人の名前は記載されません。
  • あなたがバックエンドから顧客のリンクを解除したとき: Anthropicはメールを送信します。
  • あなたがConsoleで顧客のリンクを解除したとき: Anthropicはメールを送信しません。

Anthropicは、メールが送信または配信されることを保証しません。顧客のリンクを解除する場合は、あなた自身から顧客に伝えてください。顧客にリンクされていることを伝える手段として、これらのメールに依存しないでください。

支出上限

顧客は、アプリに対する月間の支出上限を米ドル(USD)で設定できます。承認ページではこの上限を月間支出制限と呼んでおり、リンクするユーザーはそこで上限を設定できます(リンクを参照)。これは、組織全体に適用される組織の月間支出上限とは別のものです。顧客の上限や、そのうちどれだけが使用されたかを読み取ることはできません。

アプリを通じた顧客の支出が上限に達すると、Claude APIは顧客に請求するリクエストを402で拒否します。想定されるエラーを参照してください。拒否は、翌月1日の00:00 UTCまで、または顧客が上限を引き上げるか削除するまで続きます。上限の変更が反映されるまでに約1分かかることがあります。

リンク後は、管理者または請求のロールを持つ顧客の組織のメンバーが、ConsoleのLinked platformsページで上限を管理します:

  • 上限を設定または変更する: アプリをクリックし、Set spend capまたはEdit spend capをクリックします。
  • デフォルトを設定する: Default spend capの下で、Set defaultまたはEditをクリックします。独自の上限を持たない各リンク済みアプリは、毎月デフォルトの金額まで支出できます。アプリ間でデフォルトを共有することはありません。
  • 上限を削除する: アプリをクリックし、Edit spend cap、次にRemove capをクリックします。その後、アプリにはデフォルトが適用されます。デフォルトがない場合は上限なしになります。

最小の上限は0米ドルで、その場合、その顧客に請求するすべてのリクエストが拒否されます。Consoleではドル単位の整数を入力でき、実質的な最大値はありません。上限では、トークンのコストとウェブ検索の料金が、交渉による割引適用前の定価で計算されます。顧客の請求額は、上限で計算される金額と異なる場合があります。

上限は、顧客が支出上限で設定する組織の月間支出上限より高く設定できます。Claude APIは、どちらか一方に達した時点で、顧客に請求するリクエストを拒否します。

アプリのテスト中

アプリがテスト中、審査中、または未承認の間に誰かがアプリをリンクするか、その上限を変更する場合は、常に以下の制限が適用されます:

テスト中、審査中、または未承認アプリの公開後
承認ページでの月間支出制限必須、50米ドル以下任意
承認ページの金額フィールド50米ドルから始まる空の状態で始まる
承認ページのContinue without a limit提供されない提供される
Consoleでの上限の削除不可可能
顧客が設定できる最大の上限50米ドル実質的な最大値なし

アプリが公開されると、それ以前に顧客が保存した上限はそのまま維持されます。その後、顧客はそれを引き上げたり削除したりできます。

顧客のサポート

顧客に請求するClaudeの使用量を含め、アプリに関するすべての事項について顧客をサポートするのはあなたです。Anthropicは顧客に承認ページと、Claude ConsoleのLinked platformsページを提供しています。Linked platformsページでは、管理者または請求のロールを持つメンバーが、今月アプリによって組織にかかった費用を確認できます。また、アプリに月間の支出上限を設定したり、アプリのリンクを解除したりすることもできます。アプリに関するその他のすべての質問はあなたに寄せられるべきものですので、顧客にあなたへの連絡方法を伝えてください。

コードスニペットの初期化

このページのPythonの例は、以下の共通のセットアップを使用しており、これは一度だけ記述します。以下を定義します:

  • インポート
  • アプリのクライアントIDとリダイレクトURI
  • 請求ベータヘッダーの値
  • サービスアカウントとして認証するClaude APIクライアント
  • client_assertion。バックエンドがauth.claude.comに送信するクライアントアサーションを返します
# Python の例では、以下の初期化と変数を前提としています
import secrets
from urllib.parse import urlencode

import anthropic
import httpx
from anthropic.lib.credentials import IdentityTokenFile
from anthropic.types import Message
from anthropic.types.beta import BetaMessage
from authlib.oauth2.rfc7636 import create_s256_code_challenge

AUTH = "https://auth.claude.com"
# OAuth アプリを登録した後、platform.claude.com からコピーします。
CLIENT_ID = "YOUR_CLIENT_ID"
REDIRECT_URI = "https://app.example.com/claude/billing/callback"
JWT_BEARER = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer"
BILLING_BETA = "user-profiles-billing-2026-10-01"

# API クライアント。SDK はワークロードの ID JWT をアクセストークンと交換し、
# 更新も行うため、"Bearer <access token>" を自分で扱う必要はありません。
client = anthropic.Anthropic()

# auth.claude.com 用のクライアントアサーション: ID JWT そのもので、ファイルがローテーションされるため
# 呼び出しごとに新たに読み込みます。アプリのクライアント認証設定で
# フェデレーションルールと異なる audience を指定している場合は、これを
# 2 つ目のトークンファイルに向けます: IdentityTokenFile("/path/to/other/token")。
client_assertion = IdentityTokenFile()

このページは役に立ちましたか?