The whole hunk
from line 136, old and new numbered
/
lines
The two sides of this change are more than 400 edits apart, too far apart to line up, so this is the differ's own diff of it and the words inside a line are not marked.
from line 136
136136
137137<Tabs>
138138 <Tab title="Claude Platform">
139 <Steps>
140 <Step title="Register the key with Anthropic">
141 Create an external key configuration through the Admin API, using the resource name from the Note the full key resource name step under Encryption key setup.
142
143 <CodeGroup>
144 ```bash cURL
145 curl -sS "https://api.anthropic.com/v1/organizations/external_keys" \
146 -H "x-api-key: $ANTHROPIC_API_KEY" \
147 -H "anthropic-version: 2023-06-01" \
148 -H "content-type: application/json" \
149 -d '{
150 "display_name": "<friendly-name>",
151 "geo": "us",
152 "provider_config": {
153 "type": "gcp",
154 "key_name": "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
139 You can set up the key in the Claude Console or through the Admin API, with the same result.
140
141 <Tabs>
142 <Tab title="Claude Console">
143 <Steps>
144 <Step title="Register the key with Anthropic">
145 In the Claude Console, open **Settings > Encryption keys** and click **Add key**. Enter a display name, choose **Google Cloud KMS**, and click **Continue**. Paste the full key resource name into **Key resource name**, and click **Add**.
146 </Step>
147
148 <Step title="Validate the key">
149 On the **Encryption keys** page, click **Verify** next to the key. **Connected** appears when the check passes. If it fails, a message gives the reason.
150 </Step>
151
152 <Step title="Attach the key to a workspace">
153 Open **Settings > Workspaces**, choose the workspace, and open its **Security** tab. Under **Encryption key**, select the key, click **Save**, and confirm. Attaching a key can't be undone. For a workspace that already receives requests, the key can take [up to a day to take effect](https://platform.claude.com/docs/en/manage-claude/cmek#how-it-works).
154 </Step>
155 </Steps>
156 </Tab>
157
158 <Tab title="API">
159 <Steps>
160 <Step title="Register the key with Anthropic">
161 Create an external key configuration through the Admin API, using the resource name from the Note the full key resource name step under Encryption key setup.
162
163 <CodeGroup>
164 ```bash cURL
165 curl -sS "https://api.anthropic.com/v1/organizations/external_keys" \
166 -H "x-api-key: $ANTHROPIC_API_KEY" \
167 -H "anthropic-version: 2023-06-01" \
168 -H "content-type: application/json" \
169 -d '{
170 "display_name": "<friendly-name>",
171 "geo": "us",
172 "provider_config": {
173 "type": "gcp",
174 "key_name": "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
175 }
176 }'
177 ```
178
179 ```bash CLI
180 ant beta:organization:external-keys create <<'YAML'
181 display_name: "<friendly-name>"
182 geo: us
183 provider_config:
184 type: gcp
185 key_name: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
186 YAML
187 ```
188
189 ```python Python
190 client = anthropic.Anthropic()
191
192 external_key = client.beta.organization.external_keys.create(
193 display_name="<friendly-name>",
194 geo="us",
195 provider_config={
196 "type": "gcp",
197 "key_name": "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>",
198 },
199 )
200
201 print(f"id: {external_key.id}")
202 print(f"display_name: {external_key.display_name}")
203 ```
204
205 ```typescript TypeScript
206 const client = new Anthropic();
207
208 const externalKey = await client.beta.organization.externalKeys.create({
209 display_name: "<friendly-name>",
210 geo: "us",
211 provider_config: {
212 type: "gcp",
213 key_name:
214 "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
215 }
216 });
217
218 console.log(`id: ${externalKey.id}`);
219 console.log(`display_name: ${externalKey.display_name}`);
220 ```
221
222 ```csharp C#
223 using Anthropic.Models.Beta.Organization.ExternalKeys;
224
225 AnthropicClient client = new();
226
227 var externalKey = await client.Beta.Organization.ExternalKeys.Create(new()
228 {
229 DisplayName = "<friendly-name>",
230 Geo = Geo.Us,
231 ProviderConfig = new BetaGcpExternalKeyConfig
232 {
233 KeyName = "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
234 }
235 });
236
237 Console.WriteLine($"id: {externalKey.ID}");
238 Console.WriteLine($"display_name: {externalKey.DisplayName}");
239 ```
240
241 ```go Go
242 client := anthropic.NewClient()
243
244 externalKey, err := client.Beta.Organization.ExternalKeys.New(context.Background(), anthropic.BetaOrganizationExternalKeyNewParams{
245 DisplayName: anthropic.String("<friendly-name>"),
246 Geo: anthropic.BetaOrganizationExternalKeyNewParamsGeoUs,
247 ProviderConfig: anthropic.BetaOrganizationExternalKeyNewParamsProviderConfigUnion{
248 OfGCP: &anthropic.BetaGCPExternalKeyConfigParam{
249 KeyName: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>",
250 },
251 },
252 })
253 if err != nil {
254 log.Fatal(err)
155255 }
156 }'
157 ```
158
159 ```bash CLI
160 ant beta:organization:external-keys create <<'YAML'
161 display_name: "<friendly-name>"
162 geo: us
163 provider_config:
164 type: gcp
165 key_name: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
166 YAML
167 ```
168
169 ```python Python
170 client = anthropic.Anthropic()
171
172 external_key = client.beta.organization.external_keys.create(
173 display_name="<friendly-name>",
174 geo="us",
175 provider_config={
176 "type": "gcp",
177 "key_name": "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>",
178 },
179 )
180
181 print(f"id: {external_key.id}")
182 print(f"display_name: {external_key.display_name}")
183 ```
184
185 ```typescript TypeScript
186 const client = new Anthropic();
187
188 const externalKey = await client.beta.organization.externalKeys.create({
189 display_name: "<friendly-name>",
190 geo: "us",
191 provider_config: {
192 type: "gcp",
193 key_name:
194 "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
256
257 fmt.Printf("id: %s\n", externalKey.ID)
258 fmt.Printf("display_name: %s\n", externalKey.DisplayName)
259 ```
260
261 ```java Java
262 import com.anthropic.models.beta.organization.externalkeys.ExternalKeyCreateParams;
263
264 void main() {
265 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
266
267 var params = ExternalKeyCreateParams.builder()
268 .displayName("<friendly-name>")
269 .geo(ExternalKeyCreateParams.Geo.US)
270 .gcpProviderConfig("projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>")
271 .build();
272 var externalKey = client.beta().organization().externalKeys().create(params);
273
274 IO.println("id: " + externalKey.id());
275 IO.println("display_name: " + externalKey.displayName().orElseThrow());
276 }
277 ```
278
279 ```php PHP
280 use Anthropic\Beta\Organization\ExternalKeys\ExternalKeyCreateParams\Geo;
281 // ...
282
283 $client = new Client();
284
285 $externalKey = $client->beta->organization->externalKeys->create(
286 displayName: '<friendly-name>',
287 geo: Geo::US,
288 providerConfig: [
289 'type' => 'gcp',
290 'keyName' => 'projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>',
291 ],
292 );
293
294 echo "id: {$externalKey->id}\n";
295 echo "display_name: {$externalKey->displayName}\n";
296 ```
297
298 ```ruby Ruby
299 client = Anthropic::Client.new
300
301 external_key = client.beta.organization.external_keys.create(
302 display_name: "<friendly-name>",
303 geo: :us,
304 provider_config: {
305 type: :gcp,
306 key_name: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
307 }
308 )
309
310 puts "id: #{external_key.id}"
311 puts "display_name: #{external_key.display_name}"
312 ```
313 </CodeGroup>
314
315 The response contains the external key ID:
316
317 ```json
318 {
319 "type": "external_key",
320 "id": "ekey_<id>",
321 "display_name": "<friendly-name>"
195322 }
196 });
197
198 console.log(`id: ${externalKey.id}`);
199 console.log(`display_name: ${externalKey.display_name}`);
200 ```
201
202 ```csharp C#
203 using Anthropic.Models.Beta.Organization.ExternalKeys;
204
205 AnthropicClient client = new();
206
207 var externalKey = await client.Beta.Organization.ExternalKeys.Create(new()
208 {
209 DisplayName = "<friendly-name>",
210 Geo = Geo.Us,
211 ProviderConfig = new BetaGcpExternalKeyConfig
323 ```
324 </Step>
325
326 <Step title="Validate the key">
327 Trigger an encrypt and decrypt round-trip against your key.
328
329 <CodeGroup>
330 ```bash cURL
331 curl -sS -X POST "https://api.anthropic.com/v1/organizations/external_keys/ekey_<id>/validate" \
332 -H "x-api-key: $ANTHROPIC_API_KEY" \
333 -H "anthropic-version: 2023-06-01"
334 ```
335
336 ```bash CLI
337 ant beta:organization:external-keys validate --external-key-id "ekey_<id>"
338 ```
339
340 ```python Python
341 client = anthropic.Anthropic()
342
343 validation = client.beta.organization.external_keys.validate("ekey_<id>")
344
345 print(f"status: {validation.status}")
346 print(f"error: {validation.error}")
347 ```
348
349 ```typescript TypeScript
350 const client = new Anthropic();
351
352 const validation = await client.beta.organization.externalKeys.validate("ekey_<id>");
353
354 console.log(`status: ${validation.status}`);
355 console.log(`error: ${validation.error}`);
356 ```
357
358 ```csharp C#
359 AnthropicClient client = new();
360
361 var validation = await client.Beta.Organization.ExternalKeys.Validate("ekey_<id>");
362
363 Console.WriteLine($"status: {validation.Status.Raw()}");
364 Console.WriteLine($"error: {validation.Error}");
365 ```
366
367 ```go Go
368 client := anthropic.NewClient()
369
370 validation, err := client.Beta.Organization.ExternalKeys.Validate(context.Background(), "ekey_<id>")
371 if err != nil {
372 log.Fatal(err)
373 }
374
375 fmt.Printf("status: %s\n", validation.Status)
376 fmt.Printf("error: %s\n", validation.Error)
377 ```
378
379 ```java Java
380 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
381
382 var validation = client.beta().organization().externalKeys().validate("ekey_<id>");
383
384 IO.println("status: " + validation.status().asString());
385 IO.println("error: " + validation.error().orElse(""));
386 ```
387
388 ```php PHP
389 $client = new Client();
390
391 $validation = $client->beta->organization->externalKeys->validate(
392 externalKeyID: 'ekey_<id>',
393 );
394
395 echo "status: {$validation->status}\n";
396 echo "error: {$validation->error}\n";
397 ```
398
399 ```ruby Ruby
400 client = Anthropic::Client.new
401
402 external_key_id = "ekey_<id>"
403 validation = client.beta.organization.external_keys.validate(external_key_id)
404
405 puts "status: #{validation.status}"
406 puts "error: #{validation.error}"
407 ```
408 </CodeGroup>
409
410 A successful response looks like this:
411
412 ```json
413 { "type": "external_key_validation", "status": "success", "error": null }
414 ```
415
416 If validation fails, common causes are:
417
418 * **VPC Service Controls:** if a service perimeter protects Cloud KMS in your project, add Anthropic to an access level on the perimeter (or exclude the key's project) so Anthropic can reach the key.
419 * **Domain restricted sharing:** the `constraints/iam.allowedPolicyMemberDomains` org policy can strip the Anthropic service account binding (see the earlier note). Confirm the binding is present with `gcloud kms keys get-iam-policy <your-key-name> --project=<your-project-id> --location=<region> --keyring=<your-keyring-name>`.
420 * **Disabled or destroyed key version:** confirm the key's primary version is enabled, and not disabled, scheduled for destruction, or destroyed.
421 </Step>
422
423 <Step title="Attach the key to a workspace">
424 Once the key is validated, attach it to a new workspace before you send any requests to that workspace. For a workspace that already receives requests, the key can take [up to a day to take effect](https://platform.claude.com/docs/en/manage-claude/cmek#how-it-works).
425
426 <CodeGroup>
427 ```bash cURL
428 curl -sS -X POST "https://api.anthropic.com/v1/organizations/workspaces/<workspace-id>" \
429 -H "x-api-key: $ANTHROPIC_API_KEY" \
430 -H "anthropic-version: 2023-06-01" \
431 -H "content-type: application/json" \
432 -d '{
433 "external_key_id": "ekey_<id>"
434 }'
435 ```
436
437 ```bash CLI
438 ant beta:organization:workspaces update \
439 --workspace-id "<workspace-id>" \
440 --external-key-id "ekey_<id>"
441 ```
442
443 ```python Python
444 client = anthropic.Anthropic()
445
446 workspace = client.beta.organization.workspaces.update(
447 "<workspace-id>", external_key_id="ekey_<id>"
448 )
449
450 print(f"id: {workspace.id}")
451 print(f"external_key_id: {workspace.external_key_id}")
452 ```
453
454 ```typescript TypeScript
455 const client = new Anthropic();
456
457 const workspace = await client.beta.organization.workspaces.update("<workspace-id>", {
458 external_key_id: "ekey_<id>"
459 });
460
461 console.log(`id: ${workspace.id}`);
462 console.log(`external_key_id: ${workspace.external_key_id}`);
463 ```
464
465 ```csharp C#
466 AnthropicClient client = new();
467
468 var workspace = await client.Beta.Organization.Workspaces.Update("<workspace-id>", new()
212469 {
213 KeyName = "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
470 ExternalKeyID = "ekey_<id>"
471 });
472
473 Console.WriteLine($"id: {workspace.ID}");
474 Console.WriteLine($"external_key_id: {workspace.ExternalKeyID}");
475 ```
476
477 ```go Go
478 client := anthropic.NewClient()
479
480 workspace, err := client.Beta.Organization.Workspaces.Update(
481 context.Background(),
482 "<workspace-id>",
483 anthropic.BetaOrganizationWorkspaceUpdateParams{
484 ExternalKeyID: anthropic.String("ekey_<id>"),
485 },
486 )
487 if err != nil {
488 log.Fatal(err)
214489 }
215 });
216
217 Console.WriteLine($"id: {externalKey.ID}");
218 Console.WriteLine($"display_name: {externalKey.DisplayName}");
219 ```
220
221 ```go Go
222 client := anthropic.NewClient()
223
224 externalKey, err := client.Beta.Organization.ExternalKeys.New(context.Background(), anthropic.BetaOrganizationExternalKeyNewParams{
225 DisplayName: anthropic.String("<friendly-name>"),
226 Geo: anthropic.BetaOrganizationExternalKeyNewParamsGeoUs,
227 ProviderConfig: anthropic.BetaOrganizationExternalKeyNewParamsProviderConfigUnion{
228 OfGCP: &anthropic.BetaGCPExternalKeyConfigParam{
229 KeyName: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>",
230 },
231 },
232 })
233 if err != nil {
234 log.Fatal(err)
235 }
236
237 fmt.Printf("id: %s\n", externalKey.ID)
238 fmt.Printf("display_name: %s\n", externalKey.DisplayName)
239 ```
240
241 ```java Java
242 import com.anthropic.models.beta.organization.externalkeys.ExternalKeyCreateParams;
243
244 void main() {
245 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
246
247 var params = ExternalKeyCreateParams.builder()
248 .displayName("<friendly-name>")
249 .geo(ExternalKeyCreateParams.Geo.US)
250 .gcpProviderConfig("projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>")
251 .build();
252 var externalKey = client.beta().organization().externalKeys().create(params);
253
254 IO.println("id: " + externalKey.id());
255 IO.println("display_name: " + externalKey.displayName().orElseThrow());
256 }
257 ```
258
259 ```php PHP
260 use Anthropic\Beta\Organization\ExternalKeys\ExternalKeyCreateParams\Geo;
261 // ...
262
263 $client = new Client();
264
265 $externalKey = $client->beta->organization->externalKeys->create(
266 displayName: '<friendly-name>',
267 geo: Geo::US,
268 providerConfig: [
269 'type' => 'gcp',
270 'keyName' => 'projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>',
271 ],
272 );
273
274 echo "id: {$externalKey->id}\n";
275 echo "display_name: {$externalKey->displayName}\n";
276 ```
277
278 ```ruby Ruby
279 client = Anthropic::Client.new
280
281 external_key = client.beta.organization.external_keys.create(
282 display_name: "<friendly-name>",
283 geo: :us,
284 provider_config: {
285 type: :gcp,
286 key_name: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
287 }
288 )
289
290 puts "id: #{external_key.id}"
291 puts "display_name: #{external_key.display_name}"
292 ```
293 </CodeGroup>
294
295 The response contains the external key ID:
296
297 ```json
298 {
299 "type": "external_key",
300 "id": "ekey_<id>",
301 "display_name": "<friendly-name>"
302 }
303 ```
304 </Step>
305
306 <Step title="Validate the key">
307 Trigger an encrypt and decrypt round-trip against your key.
308
309 <CodeGroup>
310 ```bash cURL
311 curl -sS -X POST "https://api.anthropic.com/v1/organizations/external_keys/ekey_<id>/validate" \
312 -H "x-api-key: $ANTHROPIC_API_KEY" \
313 -H "anthropic-version: 2023-06-01"
314 ```
315
316 ```bash CLI
317 ant beta:organization:external-keys validate --external-key-id "ekey_<id>"
318 ```
319
320 ```python Python
321 client = anthropic.Anthropic()
322
323 validation = client.beta.organization.external_keys.validate("ekey_<id>")
324
325 print(f"status: {validation.status}")
326 print(f"error: {validation.error}")
327 ```
328
329 ```typescript TypeScript
330 const client = new Anthropic();
331
332 const validation = await client.beta.organization.externalKeys.validate("ekey_<id>");
333
334 console.log(`status: ${validation.status}`);
335 console.log(`error: ${validation.error}`);
336 ```
337
338 ```csharp C#
339 AnthropicClient client = new();
340
341 var validation = await client.Beta.Organization.ExternalKeys.Validate("ekey_<id>");
342
343 Console.WriteLine($"status: {validation.Status.Raw()}");
344 Console.WriteLine($"error: {validation.Error}");
345 ```
346
347 ```go Go
348 client := anthropic.NewClient()
349
350 validation, err := client.Beta.Organization.ExternalKeys.Validate(context.Background(), "ekey_<id>")
351 if err != nil {
352 log.Fatal(err)
353 }
354
355 fmt.Printf("status: %s\n", validation.Status)
356 fmt.Printf("error: %s\n", validation.Error)
357 ```
358
359 ```java Java
360 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
361
362 var validation = client.beta().organization().externalKeys().validate("ekey_<id>");
363
364 IO.println("status: " + validation.status().asString());
365 IO.println("error: " + validation.error().orElse(""));
366 ```
367
368 ```php PHP
369 $client = new Client();
370
371 $validation = $client->beta->organization->externalKeys->validate(
372 externalKeyID: 'ekey_<id>',
373 );
374
375 echo "status: {$validation->status}\n";
376 echo "error: {$validation->error}\n";
377 ```
378
379 ```ruby Ruby
380 client = Anthropic::Client.new
381
382 external_key_id = "ekey_<id>"
383 validation = client.beta.organization.external_keys.validate(external_key_id)
384
385 puts "status: #{validation.status}"
386 puts "error: #{validation.error}"
387 ```
388 </CodeGroup>
389
390 A successful response looks like this:
391
392 ```json
393 { "type": "external_key_validation", "status": "success", "error": null }
394 ```
395
396 If validation fails, common causes are:
397
398 * **VPC Service Controls:** if a service perimeter protects Cloud KMS in your project, add Anthropic to an access level on the perimeter (or exclude the key's project) so Anthropic can reach the key.
399 * **Domain restricted sharing:** the `constraints/iam.allowedPolicyMemberDomains` org policy can strip the Anthropic service account binding (see the earlier note). Confirm the binding is present with `gcloud kms keys get-iam-policy <your-key-name> --project=<your-project-id> --location=<region> --keyring=<your-keyring-name>`.
400 * **Disabled or destroyed key version:** confirm the key's primary version is enabled, and not disabled, scheduled for destruction, or destroyed.
401 </Step>
402
403 <Step title="Attach the key to a workspace">
404 Once the key is validated, attach it to a new workspace before you send any requests to that workspace. For a workspace that already receives requests, the key can take [up to a day to take effect](https://platform.claude.com/docs/en/manage-claude/cmek#how-it-works).
405
406 <CodeGroup>
407 ```bash cURL
408 curl -sS -X POST "https://api.anthropic.com/v1/organizations/workspaces/<workspace-id>" \
409 -H "x-api-key: $ANTHROPIC_API_KEY" \
410 -H "anthropic-version: 2023-06-01" \
411 -H "content-type: application/json" \
412 -d '{
413 "external_key_id": "ekey_<id>"
414 }'
415 ```
416
417 ```bash CLI
418 ant beta:organization:workspaces update \
419 --workspace-id "<workspace-id>" \
420 --external-key-id "ekey_<id>"
421 ```
422
423 ```python Python
424 client = anthropic.Anthropic()
425
426 workspace = client.beta.organization.workspaces.update(
427 "<workspace-id>", external_key_id="ekey_<id>"
428 )
429
430 print(f"id: {workspace.id}")
431 print(f"external_key_id: {workspace.external_key_id}")
432 ```
433
434 ```typescript TypeScript
435 const client = new Anthropic();
436
437 const workspace = await client.beta.organization.workspaces.update("<workspace-id>", {
438 external_key_id: "ekey_<id>"
439 });
440
441 console.log(`id: ${workspace.id}`);
442 console.log(`external_key_id: ${workspace.external_key_id}`);
443 ```
444
445 ```csharp C#
446 AnthropicClient client = new();
447
448 var workspace = await client.Beta.Organization.Workspaces.Update("<workspace-id>", new()
449 {
450 ExternalKeyID = "ekey_<id>"
451 });
452
453 Console.WriteLine($"id: {workspace.ID}");
454 Console.WriteLine($"external_key_id: {workspace.ExternalKeyID}");
455 ```
456
457 ```go Go
458 client := anthropic.NewClient()
459
460 workspace, err := client.Beta.Organization.Workspaces.Update(
461 context.Background(),
462 "<workspace-id>",
463 anthropic.BetaOrganizationWorkspaceUpdateParams{
464 ExternalKeyID: anthropic.String("ekey_<id>"),
465 },
466 )
467 if err != nil {
468 log.Fatal(err)
469 }
470
471 fmt.Printf("id: %s\n", workspace.ID)
472 fmt.Printf("external_key_id: %s\n", workspace.ExternalKeyID)
473 ```
474
475 ```java Java
476 import com.anthropic.models.beta.organization.workspaces.WorkspaceUpdateParams;
477
478 void main() {
479 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
480
481 var params = WorkspaceUpdateParams.builder()
482 .externalKeyId("ekey_<id>")
483 .build();
484 var workspace = client.beta().organization().workspaces().update("<workspace-id>", params);
485
486 IO.println("id: " + workspace.id());
487 IO.println("external_key_id: " + workspace.externalKeyId().orElseThrow());
488 }
489 ```
490
491 ```php PHP
492 $client = new Client();
493
494 $workspace = $client->beta->organization->workspaces->update(
495 workspaceID: '<workspace-id>',
496 externalKeyID: 'ekey_<id>',
497 );
498
499 echo "id: {$workspace->id}\n";
500 echo "external_key_id: {$workspace->externalKeyID}\n";
501 ```
502
503 ```ruby Ruby
504 client = Anthropic::Client.new
505
506 workspace_id = "<workspace-id>"
507 workspace = client.beta.organization.workspaces.update(
508 workspace_id,
509 external_key_id: "ekey_<id>"
510 )
511
512 puts "id: #{workspace.id}"
513 puts "external_key_id: #{workspace.external_key_id}"
514 ```
515 </CodeGroup>
516 </Step>
517 </Steps>
490
491 fmt.Printf("id: %s\n", workspace.ID)
492 fmt.Printf("external_key_id: %s\n", workspace.ExternalKeyID)
493 ```
494
495 ```java Java
496 import com.anthropic.models.beta.organization.workspaces.WorkspaceUpdateParams;
497
498 void main() {
499 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
500
501 var params = WorkspaceUpdateParams.builder()
502 .externalKeyId("ekey_<id>")
503 .build();
504 var workspace = client.beta().organization().workspaces().update("<workspace-id>", params);
505
506 IO.println("id: " + workspace.id());
507 IO.println("external_key_id: " + workspace.externalKeyId().orElseThrow());
508 }
509 ```
510
511 ```php PHP
512 $client = new Client();
513
514 $workspace = $client->beta->organization->workspaces->update(
515 workspaceID: '<workspace-id>',
516 externalKeyID: 'ekey_<id>',
517 );
518
519 echo "id: {$workspace->id}\n";
520 echo "external_key_id: {$workspace->externalKeyID}\n";
521 ```
522
523 ```ruby Ruby
524 client = Anthropic::Client.new
525
526 workspace_id = "<workspace-id>"
527 workspace = client.beta.organization.workspaces.update(
528 workspace_id,
529 external_key_id: "ekey_<id>"
530 )
531
532 puts "id: #{workspace.id}"
533 puts "external_key_id: #{workspace.external_key_id}"
534 ```
535 </CodeGroup>
536 </Step>
537 </Steps>
538 </Tab>
539 </Tabs>
518540 </Tab>
519541
520542 <Tab title="Claude Enterprise">
521543