Home Docs Claude Developer Platform 26 Aug 2026

One change · api

rate-limits-api changedmanage-claude/rate-limits-api

Nearest release: v2.1.247, published under an hour before this site recorded the change. Shown because the two are within 24 hours of each other. Nothing here says the release caused the edit.

Recorded here 26 Aug 2026 18:08 UTC

Lines+643added

Lines−25removed

From line 20 where the diff opens

First seen 14 Aug 2026 this site's first read of the page

Recorded edits17to this page, all time

The whole hunk

from line 20, 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 20

2020 **Admin API key required.** These endpoints require an Admin API key, which is different from a standard Claude API key. See [Create an Admin API key](https://platform.claude.com/docs/en/manage-claude/admin-api-keys) to find where to create one for your organization type and which scopes to select.

2121</Check>

2222

23The SDK and CLI examples on this page construct the default client, which reads the Admin API key from the `ANTHROPIC_API_KEY` environment variable. The SDKs expose these endpoints as `client.beta.organization.rate_limits` and `client.beta.organization.workspaces.rate_limits`; the Python, TypeScript, C#, Go, and Java list methods return an iterator that follows `next_page` for you, while the PHP, Ruby, and curl examples read one page.

2325## Quick start

2426

2527List the rate limits configured for your organization:

2628

27```bash cURL

28curl "https://api.anthropic.com/v1/organizations/rate_limits" \

29 --header "anthropic-version: 2023-06-01" \

30 --header "x-api-key: $ANTHROPIC_ADMIN_KEY"

31```

29<CodeGroup>

30 ```bash cURL

31 curl "https://api.anthropic.com/v1/organizations/rate_limits" \

32 -H "x-api-key: $ANTHROPIC_API_KEY" \

33 -H "anthropic-version: 2023-06-01"

34 ```

36 ```bash CLI

37 ant beta:organization:rate-limits list

38 ```

40 ```python Python

41 client = anthropic.Anthropic()

43 rate_limits = client.beta.organization.rate_limits.list()

45 for group in rate_limits:

46 models = f" ({', '.join(group.models)})" if group.models else ""

47 print(f"{group.group_type}{models}")

48 for limit in group.limits:

49 print(f" {limit.type}: {limit.value}")

50 ```

52 ```typescript TypeScript

53 const client = new Anthropic();

55 const rateLimits = await client.beta.organization.rateLimits.list();

57 for await (const group of rateLimits) {

58 const models = group.models ? ` (${group.models.join(", ")})` : "";

59 console.log(`${group.group_type}${models}`);

60 for (const limit of group.limits) {

61 console.log(` ${limit.type}: ${limit.value}`);

62 }

63 }

64 ```

66 ```csharp C#

67 AnthropicClient client = new();

69 var rateLimits = await client.Beta.Organization.RateLimits.List();

71 await foreach (var group in rateLimits.Paginate())

72 {

73 var models = group.Models is null ? "" : $" ({string.Join(", ", group.Models)})";

74 Console.WriteLine($"{group.GroupType.Raw()}{models}");

75 foreach (var limit in group.Limits)

76 {

77 Console.WriteLine($" {limit.Type}: {limit.Value}");

78 }

79 }

80 ```

82 ```go Go

83 client := anthropic.NewClient()

85 rateLimits := client.Beta.Organization.RateLimits.ListAutoPaging(context.Background(), anthropic.BetaOrganizationRateLimitListParams{})

87 for rateLimits.Next() {

88 group := rateLimits.Current()

89 models := ""

90 if len(group.Models) > 0 {

91 models = fmt.Sprintf(" (%s)", strings.Join(group.Models, ", "))

92 }

93 fmt.Printf("%s%s\n", group.GroupType, models)

94 for _, limit := range group.Limits {

95 fmt.Printf(" %s: %d\n", limit.Type, limit.Value)

96 }

97 }

98 if err := rateLimits.Err(); err != nil {

99 log.Fatal(err)

100 }

101 ```

102

103 ```java Java

104 AnthropicClient client = AnthropicOkHttpClient.fromEnv();

105

106 var rateLimits = client.beta().organization().rateLimits().list();

107

108 for (var group : rateLimits.autoPager()) {

109 var models = group.models()

110 .map(modelIds -> " (" + String.join(", ", modelIds) + ")")

111 .orElse("");

112 IO.println(group.groupType().asString() + models);

113 for (var limit : group.limits()) {

114 IO.println(" " + limit.type() + ": " + limit.value());

115 }

116 }

117 ```

118

119 ```php PHP

120 $client = new Client();

121

122 $rateLimits = $client->beta->organization->rateLimits->list();

123

124 foreach ($rateLimits->data as $group) {

125 $models = $group->models ? ' (' . implode(', ', $group->models) . ')' : '';

126 echo "{$group->groupType}{$models}\n";

127 foreach ($group->limits as $limit) {

128 echo " {$limit->type}: {$limit->value}\n";

129 }

130 }

131 ```

132

133 ```ruby Ruby

134 client = Anthropic::Client.new

135

136 rate_limits = client.beta.organization.rate_limits.list

137

138 rate_limits.data.each do |group|

139 models = group.models ? " (#{group.models.join(", ")})" : ""

140 puts "#{group.group_type}#{models}"

141 group.limits.each do |limit|

142 puts " #{limit.type}: #{limit.value}"

143 end

144 end

145 ```

146</CodeGroup>

32147

33148## Organization rate limits

34149

from line 160

45160

46161### List all organization rate limits

47162

48```bash cURL

49curl "https://api.anthropic.com/v1/organizations/rate_limits" \

50 --header "anthropic-version: 2023-06-01" \

51 --header "x-api-key: $ANTHROPIC_ADMIN_KEY"

52```

163<CodeGroup>

164 ```bash cURL

165 curl "https://api.anthropic.com/v1/organizations/rate_limits" \

166 -H "x-api-key: $ANTHROPIC_API_KEY" \

167 -H "anthropic-version: 2023-06-01"

168 ```

169

170 ```bash CLI

171 ant beta:organization:rate-limits list

172 ```

173

174 ```python Python

175 client = anthropic.Anthropic()

176

177 rate_limits = client.beta.organization.rate_limits.list()

178

179 for group in rate_limits:

180 models = f" ({', '.join(group.models)})" if group.models else ""

181 print(f"{group.group_type}{models}")

182 for limit in group.limits:

183 print(f" {limit.type}: {limit.value}")

184 ```

185

186 ```typescript TypeScript

187 const client = new Anthropic();

188

189 const rateLimits = await client.beta.organization.rateLimits.list();

190

191 for await (const group of rateLimits) {

192 const models = group.models ? ` (${group.models.join(", ")})` : "";

193 console.log(`${group.group_type}${models}`);

194 for (const limit of group.limits) {

195 console.log(` ${limit.type}: ${limit.value}`);

196 }

197 }

198 ```

199

200 ```csharp C#

201 AnthropicClient client = new();

202

203 var rateLimits = await client.Beta.Organization.RateLimits.List();

204

205 await foreach (var group in rateLimits.Paginate())

206 {

207 var models = group.Models is null ? "" : $" ({string.Join(", ", group.Models)})";

208 Console.WriteLine($"{group.GroupType.Raw()}{models}");

209 foreach (var limit in group.Limits)

210 {

211 Console.WriteLine($" {limit.Type}: {limit.Value}");

212 }

213 }

214 ```

215

216 ```go Go

217 client := anthropic.NewClient()

218

219 rateLimits := client.Beta.Organization.RateLimits.ListAutoPaging(context.Background(), anthropic.BetaOrganizationRateLimitListParams{})

220

221 for rateLimits.Next() {

222 group := rateLimits.Current()

223 models := ""

224 if len(group.Models) > 0 {

225 models = fmt.Sprintf(" (%s)", strings.Join(group.Models, ", "))

226 }

227 fmt.Printf("%s%s\n", group.GroupType, models)

228 for _, limit := range group.Limits {

229 fmt.Printf(" %s: %d\n", limit.Type, limit.Value)

230 }

231 }

232 if err := rateLimits.Err(); err != nil {

233 log.Fatal(err)

234 }

235 ```

236

237 ```java Java

238 AnthropicClient client = AnthropicOkHttpClient.fromEnv();

239

240 var rateLimits = client.beta().organization().rateLimits().list();

241

242 for (var group : rateLimits.autoPager()) {

243 var models = group.models()

244 .map(modelIds -> " (" + String.join(", ", modelIds) + ")")

245 .orElse("");

246 IO.println(group.groupType().asString() + models);

247 for (var limit : group.limits()) {

248 IO.println(" " + limit.type() + ": " + limit.value());

249 }

250 }

251 ```

252

253 ```php PHP

254 $client = new Client();

255

256 $rateLimits = $client->beta->organization->rateLimits->list();

257

258 foreach ($rateLimits->data as $group) {

259 $models = $group->models ? ' (' . implode(', ', $group->models) . ')' : '';

260 echo "{$group->groupType}{$models}\n";

261 foreach ($group->limits as $limit) {

262 echo " {$limit->type}: {$limit->value}\n";

263 }

264 }

265 ```

266

267 ```ruby Ruby

268 client = Anthropic::Client.new

269

270 rate_limits = client.beta.organization.rate_limits.list

271

272 rate_limits.data.each do |group|

273 models = group.models ? " (#{group.models.join(", ")})" : ""

274 puts "#{group.group_type}#{models}"

275 group.limits.each do |limit|

276 puts " #{limit.type}: #{limit.value}"

277 end

278 end

279 ```

280</CodeGroup>

53281

54282```json

55283{

from line 323

95323

96324Pass any model ID or alias as the `model` query parameter to return only the entry that contains it:

97325

98```bash cURL

99curl "https://api.anthropic.com/v1/organizations/rate_limits?model=claude-opus-5" \

100 --header "anthropic-version: 2023-06-01" \

101 --header "x-api-key: $ANTHROPIC_ADMIN_KEY"

102```

326<CodeGroup>

327 ```bash cURL

328 curl "https://api.anthropic.com/v1/organizations/rate_limits?model=claude-opus-5" \

329 -H "x-api-key: $ANTHROPIC_API_KEY" \

330 -H "anthropic-version: 2023-06-01"

331 ```

332

333 ```bash CLI

334 ant beta:organization:rate-limits list --model claude-opus-5

335 ```

336

337 ```python Python

338 client = anthropic.Anthropic()

339

340 rate_limits = client.beta.organization.rate_limits.list(model="claude-opus-5")

341

342 for group in rate_limits:

343 models = f" ({', '.join(group.models)})" if group.models else ""

344 print(f"{group.group_type}{models}")

345 for limit in group.limits:

346 print(f" {limit.type}: {limit.value}")

347 ```

348

349 ```typescript TypeScript

350 const client = new Anthropic();

351

352 const rateLimits = await client.beta.organization.rateLimits.list({ model: "claude-opus-5" });

353

354 for await (const group of rateLimits) {

355 const models = group.models ? ` (${group.models.join(", ")})` : "";

356 console.log(`${group.group_type}${models}`);

357 for (const limit of group.limits) {

358 console.log(` ${limit.type}: ${limit.value}`);

359 }

360 }

361 ```

362

363 ```csharp C#

364 AnthropicClient client = new();

365

366 var rateLimits = await client.Beta.Organization.RateLimits.List(new()

367 {

368 Model = "claude-opus-5"

369 });

370

371 await foreach (var group in rateLimits.Paginate())

372 {

373 var models = group.Models is null ? "" : $" ({string.Join(", ", group.Models)})";

374 Console.WriteLine($"{group.GroupType.Raw()}{models}");

375 foreach (var limit in group.Limits)

376 {

377 Console.WriteLine($" {limit.Type}: {limit.Value}");

378 }

379 }

380 ```

381

382 ```go Go

383 client := anthropic.NewClient()

384

385 rateLimits := client.Beta.Organization.RateLimits.ListAutoPaging(context.Background(), anthropic.BetaOrganizationRateLimitListParams{

386 Model: anthropic.String(anthropic.ModelClaudeOpus5),

387 })

388

389 for rateLimits.Next() {

390 group := rateLimits.Current()

391 models := ""

392 if len(group.Models) > 0 {

393 models = fmt.Sprintf(" (%s)", strings.Join(group.Models, ", "))

394 }

395 fmt.Printf("%s%s\n", group.GroupType, models)

396 for _, limit := range group.Limits {

397 fmt.Printf(" %s: %d\n", limit.Type, limit.Value)

398 }

399 }

400 if err := rateLimits.Err(); err != nil {

401 log.Fatal(err)

402 }

403 ```

404

405 ```java Java

406 import com.anthropic.models.beta.organization.ratelimits.RateLimitListParams;

407 import com.anthropic.models.messages.Model;

408

409 void main() {

410 AnthropicClient client = AnthropicOkHttpClient.fromEnv();

411

412 var params = RateLimitListParams.builder()

413 .model(Model.CLAUDE_OPUS_5.asString())

414 .build();

415 var rateLimits = client.beta().organization().rateLimits().list(params);

416

417 for (var group : rateLimits.autoPager()) {

418 var models = group.models()

419 .map(modelIds -> " (" + String.join(", ", modelIds) + ")")

420 .orElse("");

421 IO.println(group.groupType().asString() + models);

422 for (var limit : group.limits()) {

423 IO.println(" " + limit.type() + ": " + limit.value());

424 }

425 }

426 }

427 ```

428

429 ```php PHP

430 use Anthropic\Messages\Model;

431

432 $client = new Client();

433

434 $rateLimits = $client->beta->organization->rateLimits->list(

435 model: Model::CLAUDE_OPUS_5->value,

436 );

437

438 foreach ($rateLimits->data as $group) {

439 $models = $group->models ? ' (' . implode(', ', $group->models) . ')' : '';

440 echo "{$group->groupType}{$models}\n";

441 foreach ($group->limits as $limit) {

442 echo " {$limit->type}: {$limit->value}\n";

443 }

444 }

445 ```

446

447 ```ruby Ruby

448 client = Anthropic::Client.new

449

450 rate_limits = client.beta.organization.rate_limits.list(model: Anthropic::Model::CLAUDE_OPUS_5)

451

452 rate_limits.data.each do |group|

453 models = group.models ? " (#{group.models.join(", ")})" : ""

454 puts "#{group.group_type}#{models}"

455 group.limits.each do |limit|

456 puts " #{limit.type}: #{limit.value}"

457 end

458 end

459 ```

460</CodeGroup>

103461

104462If the model string doesn't match any group, the endpoint returns a 404 error. The `model` parameter is supported on the organization endpoint only; the workspace endpoint doesn't accept it.

105463

from line 477

119477 To retrieve your organization's workspace IDs, use the [List Workspaces](https://platform.claude.com/docs/en/api/admin/workspaces/list) endpoint, or find them in the [Claude Console](https://platform.claude.com/settings/workspaces). The default workspace cannot have rate limit overrides, so it has no entry on this endpoint; use the organization endpoint to read its limits.

120478</Tip>

121479

122```bash cURL

123curl "https://api.anthropic.com/v1/organizations/workspaces/wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ/rate_limits" \

124 --header "anthropic-version: 2023-06-01" \

125 --header "x-api-key: $ANTHROPIC_ADMIN_KEY"

126```

480<CodeGroup>

481 ```bash cURL

482 curl "https://api.anthropic.com/v1/organizations/workspaces/wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ/rate_limits" \

483 -H "x-api-key: $ANTHROPIC_API_KEY" \

484 -H "anthropic-version: 2023-06-01"

485 ```

486

487 ```bash CLI

488 ant beta:organization:workspaces:rate-limits list \

489 --workspace-id wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ

490 ```

491

492 ```python Python

493 client = anthropic.Anthropic()

494

495 rate_limits = client.beta.organization.workspaces.rate_limits.list(

496 "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"

497 )

498

499 for group in rate_limits:

500 models = f" ({', '.join(group.models)})" if group.models else ""

501 print(f"{group.group_type}{models}")

502 for limit in group.limits:

503 print(f" {limit.type}: {limit.value}")

504 ```

505

506 ```typescript TypeScript

507 const client = new Anthropic();

508

509 const rateLimits = await client.beta.organization.workspaces.rateLimits.list(

510 "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"

511 );

512

513 for await (const group of rateLimits) {

514 const models = group.models ? ` (${group.models.join(", ")})` : "";

515 console.log(`${group.group_type}${models}`);

516 for (const limit of group.limits) {

517 console.log(` ${limit.type}: ${limit.value}`);

518 }

519 }

520 ```

521

522 ```csharp C#

523 AnthropicClient client = new();

524

525 var rateLimits = await client.Beta.Organization.Workspaces.RateLimits.List(

526 "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"

527 );

528

529 await foreach (var group in rateLimits.Paginate())

530 {

531 var models = group.Models is null ? "" : $" ({string.Join(", ", group.Models)})";

532 Console.WriteLine($"{group.GroupType.Raw()}{models}");

533 foreach (var limit in group.Limits)

534 {

535 Console.WriteLine($" {limit.Type}: {limit.Value}");

536 }

537 }

538 ```

539

540 ```go Go

541 client := anthropic.NewClient()

542

543 rateLimits := client.Beta.Organization.Workspaces.RateLimits.ListAutoPaging(

544 context.Background(),

545 "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",

546 anthropic.BetaOrganizationWorkspaceRateLimitListParams{},

547 )

548

549 for rateLimits.Next() {

550 group := rateLimits.Current()

551 models := ""

552 if len(group.Models) > 0 {

553 models = fmt.Sprintf(" (%s)", strings.Join(group.Models, ", "))

554 }

555 fmt.Printf("%s%s\n", group.GroupType, models)

556 for _, limit := range group.Limits {

557 fmt.Printf(" %s: %d\n", limit.Type, limit.Value)

558 }

559 }

560 if err := rateLimits.Err(); err != nil {

561 log.Fatal(err)

562 }

563 ```

564

565 ```java Java

566 AnthropicClient client = AnthropicOkHttpClient.fromEnv();

567

568 var rateLimits = client.beta().organization().workspaces().rateLimits()

569 .list("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ");

570

571 for (var group : rateLimits.autoPager()) {

572 var models = group.models()

573 .map(modelIds -> " (" + String.join(", ", modelIds) + ")")

574 .orElse("");

575 IO.println(group.groupType().asString() + models);

576 for (var limit : group.limits()) {

577 IO.println(" " + limit.type() + ": " + limit.value());

578 }

579 }

580 ```

581

582 ```php PHP

583 $client = new Client();

584

585 $rateLimits = $client->beta->organization->workspaces->rateLimits->list(

586 workspaceID: 'wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ',

587 );

588

589 foreach ($rateLimits->data as $group) {

590 $models = $group->models ? ' (' . implode(', ', $group->models) . ')' : '';

591 echo "{$group->groupType}{$models}\n";

592 foreach ($group->limits as $limit) {

593 echo " {$limit->type}: {$limit->value}\n";

594 }

595 }

596 ```

597

598 ```ruby Ruby

599 client = Anthropic::Client.new

600

601 workspace_id = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"

602 rate_limits = client.beta.organization.workspaces.rate_limits.list(workspace_id)

603

604 rate_limits.data.each do |group|

605 models = group.models ? " (#{group.models.join(", ")})" : ""

606 puts "#{group.group_type}#{models}"

607 group.limits.each do |limit|

608 puts " #{limit.type}: #{limit.value}"

609 end

610 end

611 ```

612</CodeGroup>

127613

128614```json

129615{

from line 647

161647

162648Both endpoints accept an optional `group_type` query parameter that restricts the response to a single category:

163649

164```bash cURL

165curl "https://api.anthropic.com/v1/organizations/rate_limits?group_type=batch" \

166 --header "anthropic-version: 2023-06-01" \

167 --header "x-api-key: $ANTHROPIC_ADMIN_KEY"

168```

650<CodeGroup>

651 ```bash cURL

652 curl "https://api.anthropic.com/v1/organizations/rate_limits?group_type=batch" \

653 -H "x-api-key: $ANTHROPIC_API_KEY" \

654 -H "anthropic-version: 2023-06-01"

655 ```

656

657 ```bash CLI

658 ant beta:organization:rate-limits list --group-type batch

659 ```

660

661 ```python Python

662 client = anthropic.Anthropic()

663

664 rate_limits = client.beta.organization.rate_limits.list(group_type="batch")

665

666 for group in rate_limits:

667 models = f" ({', '.join(group.models)})" if group.models else ""

668 print(f"{group.group_type}{models}")

669 for limit in group.limits:

670 print(f" {limit.type}: {limit.value}")

671 ```

672

673 ```typescript TypeScript

674 const client = new Anthropic();

675

676 const rateLimits = await client.beta.organization.rateLimits.list({ group_type: "batch" });

677

678 for await (const group of rateLimits) {

679 const models = group.models ? ` (${group.models.join(", ")})` : "";

680 console.log(`${group.group_type}${models}`);

681 for (const limit of group.limits) {

682 console.log(` ${limit.type}: ${limit.value}`);

683 }

684 }

685 ```

686

687 ```csharp C#

688 using Anthropic.Models.Beta.Organization.RateLimits;

689

690 AnthropicClient client = new();

691

692 var rateLimits = await client.Beta.Organization.RateLimits.List(new()

693 {

694 GroupType = GroupType.Batch

695 });

696

697 await foreach (var group in rateLimits.Paginate())

698 {

699 var models = group.Models is null ? "" : $" ({string.Join(", ", group.Models)})";

700 Console.WriteLine($"{group.GroupType.Raw()}{models}");

701 foreach (var limit in group.Limits)

702 {

703 Console.WriteLine($" {limit.Type}: {limit.Value}");

704 }

705 }

706 ```

707

708 ```go Go

709 client := anthropic.NewClient()

710

711 rateLimits := client.Beta.Organization.RateLimits.ListAutoPaging(context.Background(), anthropic.BetaOrganizationRateLimitListParams{

712 GroupType: anthropic.BetaOrganizationRateLimitListParamsGroupTypeBatch,

713 })

714

715 for rateLimits.Next() {

716 group := rateLimits.Current()

717 models := ""

718 if len(group.Models) > 0 {

719 models = fmt.Sprintf(" (%s)", strings.Join(group.Models, ", "))

720 }

721 fmt.Printf("%s%s\n", group.GroupType, models)

722 for _, limit := range group.Limits {

723 fmt.Printf(" %s: %d\n", limit.Type, limit.Value)

724 }

725 }

726 if err := rateLimits.Err(); err != nil {

727 log.Fatal(err)

728 }

729 ```

730

731 ```java Java

732 import com.anthropic.models.beta.organization.ratelimits.RateLimitListParams;

733

734 void main() {

735 AnthropicClient client = AnthropicOkHttpClient.fromEnv();

736

737 var params = RateLimitListParams.builder()

738 .groupType(RateLimitListParams.GroupType.BATCH)

739 .build();

740 var rateLimits = client.beta().organization().rateLimits().list(params);

741

742 for (var group : rateLimits.autoPager()) {

743 var models = group.models()

744 .map(modelIds -> " (" + String.join(", ", modelIds) + ")")

745 .orElse("");

746 IO.println(group.groupType().asString() + models);

747 for (var limit : group.limits()) {

748 IO.println(" " + limit.type() + ": " + limit.value());

749 }

750 }

751 }

752 ```

753

754 ```php PHP

755 use Anthropic\Beta\Organization\RateLimits\RateLimitListParams\GroupType;

756 // ...

757

758 $client = new Client();

759

760 $rateLimits = $client->beta->organization->rateLimits->list(

761 groupType: GroupType::BATCH,

762 );

763

764 foreach ($rateLimits->data as $group) {

765 $models = $group->models ? ' (' . implode(', ', $group->models) . ')' : '';

766 echo "{$group->groupType}{$models}\n";

767 foreach ($group->limits as $limit) {

768 echo " {$limit->type}: {$limit->value}\n";

769 }

770 }

771 ```

772

773 ```ruby Ruby

774 client = Anthropic::Client.new

775

776 rate_limits = client.beta.organization.rate_limits.list(group_type: :batch)

777

778 rate_limits.data.each do |group|

779 models = group.models ? " (#{group.models.join(", ")})" : ""

780 puts "#{group.group_type}#{models}"

781 group.limits.each do |limit|

782 puts " #{limit.type}: #{limit.value}"

783 end

784 end

785 ```

786</CodeGroup>

169787

170788Valid values are `model_group`, `batch`, `token_count`, `files`, `skills`, and `web_search`.

171789

172790

This page’s history 17 edits

22 Oct 2026 +1 −1
21 Oct 2026 +3 −3
21 Oct 2026 +1 −1
21 Oct 2026 +20 −7
21 Oct 2026 +3 −1
20 Oct 2026 +4 −2

The page’s own history →

Where it came from

The captureapi
Upstream pageplatform.claude.com

Around it

Every changethe ledger
That day26 Aug 2026