@@ -46,15 +46,43 @@ const link = new RPCLink({
 </CodeGroup>
 
 :::warning
-`BatchHandlerPlugin` detects batch requests by checking for the `orpc-batch` header, so cross-origin batch requests need CORS to allow it. The [CORS Plugin](/docs/plugins/cors) allows requested headers by default. If you set `allowHeaders` or configure CORS elsewhere, include `orpc-batch` along with `Content-Type` and any other headers your clients send:
+`BatchHandlerPlugin` recognizes batch requests by the `orpc-batch` header (exported as `BATCH_HEADER`), so make sure nothing between the client and server blocks or strips it, such as a CORS policy or proxy. This is usually fine by default, as the [CORS Plugin](/docs/plugins/cors) allows the headers a request asks for.
+:::
 
-```ts
-const cors = new CORSHandlerPlugin({
-  allowHeaders: ['Content-Type', 'orpc-batch'],
+## Max Size
+
+Both plugins limit how many requests a batch holds with `maxSize`, and each side defaults to `DEFAULT_BATCH_MAX_SIZE` (10) independently. The client splits a larger group into several batches, while the server rejects a larger batch with a `413` for every request in it, so keep the client limit at or below the server's.
+
+<CodeGroup>
+
+```ts server.ts
+const handler = new RPCHandler(router, {
+  plugins: [
+    new BatchHandlerPlugin({
+      maxSize: 20,
+    }),
+  ],
 })
 ```
 
-:::
+```ts client.ts
+const link = new RPCLink({
+  url: '/rpc',
+  plugins: [
+    new BatchLinkPlugin({
+      maxSize: 20,
+      groups: [
+        {
+          condition: () => true,
+          context: {},
+        },
+      ],
+    }),
+  ],
+})
+```
+
+</CodeGroup>
 
 ## Streaming Responses
 
 
@@ -7,6 +7,21 @@ import { captureAsyncContext, defer, isAsyncIteratorObject, loadBytes, once, pro
 import { parseStandardUrl } from '@standard-server/core'
 import { ClientPeer, decodePeerMessage, isServerPeerSendMessage } from '@standard-server/peer'
 
+/**
+ * Header that marks a request as a batch, set by the Batch Link Plugin and detected by the Batch Handler Plugin.
+ * Nothing between the client and server, such as a CORS policy or proxy, should block or strip it.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/batch#setup | Batch Plugin - Setup}
+ */
+export const BATCH_HEADER = 'orpc-batch'
+
+/**
+ * Default `maxSize` of both the Batch Link Plugin and the Batch Handler Plugin.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/batch#max-size | Batch Plugin - Max Size}
+ */
+export const DEFAULT_BATCH_MAX_SIZE = 10
+
 export interface BatchLinkPluginGroup<T extends ClientContext> {
   /**
    * Determines whether a request should be included in this batch group.
@@ -48,9 +63,11 @@ export interface BatchLinkPluginOptions<T extends ClientContext> {
   scope?: ((options: StandardLinkTransportInterceptorOptions<T>) => unknown) | undefined
 
   /**
-   * The maximum number of requests in the batch.
+   * The maximum number of requests in the batch. Larger batches are split.
+   * Keep it at or below the server Batch Handler Plugin's `maxSize`, which rejects larger batches with a `413`.
    *
-   * @default 10
+   * @default DEFAULT_BATCH_MAX_SIZE (10)
+   * @see {@link https://orpc.dev/docs/plugins/batch#max-size | Batch Plugin - Max Size}
    */
   maxSize?: Value<Promisable<number>, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]> | undefined
 
@@ -131,7 +148,7 @@ export class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPlu
     this.groups = options.groups
     this.filter = options.filter ?? (() => true)
     this.scope = options.scope ?? (() => undefined)
-    this.maxSize = options.maxSize ?? 10
+    this.maxSize = options.maxSize ?? DEFAULT_BATCH_MAX_SIZE
     this.wait = options.wait ?? 0
     this.batchUrl = options.url ?? ((options) => {
       const [pathname] = parseStandardUrl(options[0].request.url)
@@ -357,7 +374,7 @@ export class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPlu
         const request: StandardRequest = {
           url,
           method,
-          headers: { ...headers, 'orpc-batch': '1' },
+          headers: { ...headers, [BATCH_HEADER]: '1' },
           signal: controller.signal,
         }
 
 
@@ -1,6 +1,8 @@
 it('exports plugins', async () => {
   await expect(import('./index')).resolves.toMatchObject({
     BatchLinkPlugin: expect.any(Function),
+    BATCH_HEADER: 'orpc-batch',
+    DEFAULT_BATCH_MAX_SIZE: 10,
     DedupeLinkPlugin: expect.any(Function),
     RetryLinkPlugin: expect.any(Function),
     RetryAfterLinkPlugin: expect.any(Function),
 
@@ -3,7 +3,7 @@ import type { StandardHandlerOptions, StandardHandlerPlugin, StandardHandlerRout
 import type { StandardBodyHint, StandardHeaders } from '@standard-server/core'
 import { Duplex } from 'node:stream'
 import { constants, createDeflate, createDeflateRaw, createGzip } from 'node:zlib'
-import { negotiateResponseCompressionEncoding, toCompressedHeaders } from '@orpc/server/plugins'
+import { BATCH_HEADER, negotiateResponseCompressionEncoding, toCompressedHeaders } from '@orpc/server/plugins'
 import { stringifyJSON, toArray } from '@orpc/shared'
 import { flattenStandardHeader } from '@standard-server/core'
 
@@ -71,7 +71,7 @@ export class BatchResponseCompressionHandlerPlugin<T extends Context> implements
        * a batch without it belongs to a procedure serving that content type itself, whose own file
        * semantics must survive untouched.
        */
-      if (flattenStandardHeader(interceptorOptions.request.headers['orpc-batch']) === undefined) {
+      if (flattenStandardHeader(interceptorOptions.request.headers[BATCH_HEADER]) === undefined) {
         return result
       }
 
 
@@ -4,6 +4,7 @@ import type { ClientPeerSendMessage, ServerPeerSendMessage } from '@standard-ser
 import type { StandardHandlerOptions, StandardHandlerPlugin, StandardHandlerRoutingInterceptor, StandardHandlerRoutingInterceptorOptions } from '../adapters/standard'
 import type { Context } from '../context'
 import { ORPCError } from '@orpc/client'
+import { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from '@orpc/client/plugins'
 import { isAsyncIteratorObject, promiseWithResolvers, toArray, value } from '@orpc/shared'
 import { flattenStandardHeader, parseStandardUrl } from '@standard-server/core'
 import { encodePeerMessage, isClientPeerSendMessage, ServerPeer } from '@standard-server/peer'
@@ -114,9 +115,11 @@ function liftSubresponseHeaders(
 
 export interface BatchHandlerPluginOptions<T extends Context> {
   /**
-   * The max size of the batch allowed.
+   * The max size of the batch allowed. Larger batches are rejected with a `413`,
+   * so keep the client Batch Link Plugin's `maxSize` at or below it.
    *
-   * @default 10
+   * @default DEFAULT_BATCH_MAX_SIZE (10)
+   * @see {@link https://orpc.dev/docs/plugins/batch#max-size | Batch Plugin - Max Size}
    */
   maxSize?: Value<Promisable<number>, [options: StandardHandlerRoutingInterceptorOptions<T>]> | undefined
 
@@ -211,7 +214,7 @@ export class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlu
   private readonly keepAliveInterval: number
 
   constructor(options: BatchHandlerPluginOptions<T> = {}) {
-    this.maxSize = options.maxSize ?? 10
+    this.maxSize = options.maxSize ?? DEFAULT_BATCH_MAX_SIZE
 
     this.mapSubrequest = options.mapSubrequest ?? ((subRequest, { request: batchRequest }) => ({
       ...subRequest,
@@ -223,7 +226,7 @@ export class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlu
          * or `origin`, cannot be overridden by a subrequest, which is just request payload.
          */
         ...batchRequest.headers,
-        'orpc-batch': undefined, // useful in case batch plugin is used multiple times
+        [BATCH_HEADER]: undefined, // useful in case batch plugin is used multiple times
       },
     }))
 
@@ -247,7 +250,7 @@ export class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlu
 
   init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T> {
     const routingInterceptor: StandardHandlerRoutingInterceptor<T> = async (interceptorOptions) => {
-      if (flattenStandardHeader(interceptorOptions.request.headers['orpc-batch']) === undefined) {
+      if (flattenStandardHeader(interceptorOptions.request.headers[BATCH_HEADER]) === undefined) {
         return interceptorOptions.next()
       }
 
 
@@ -1,6 +1,8 @@
 it('exports plugins', async () => {
   await expect(import('.')).resolves.toMatchObject({
     BatchHandlerPlugin: expect.any(Function),
+    BATCH_HEADER: expect.any(String),
+    DEFAULT_BATCH_MAX_SIZE: expect.any(Number),
     CORSHandlerPlugin: expect.any(Function),
     RequestHeadersHandlerPlugin: expect.any(Function),
     ResponseHeadersHandlerPlugin: expect.any(Function),
 
@@ -39,3 +39,4 @@ export type {
 } from './response-headers'
 export * from './rethrow'
 export * from './timeout'
+export { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from '@orpc/client/plugins'