@@ -249,6 +249,14 @@ const handler = new OpenAPIHandler(router, {
 
 </Expandable>
 
+Error responses are sent as `application/json` by default. Use `errorResponseContentType` to change the media type, such as `application/problem+json` for [RFC 9457 Problem Details](https://www.rfc-editor.org/rfc/rfc9457):
+
+```ts
+const handler = new OpenAPIHandler(router, {
+  errorResponseContentType: 'application/problem+json',
+})
+```
+
 :::info
 If you use `OpenAPILink` with a custom server-side error format, make sure to configure [Custom Error Decoding](/docs/openapi/link#custom-error-decoding).
 :::
 
@@ -242,6 +242,14 @@ const link = new OpenAPILink(contract, {
 })
 ```
 
+If the handler sets [`errorResponseContentType`](/docs/openapi/handler#custom-error-response), set the same value on the link so those error responses are parsed as JSON:
+
+```ts
+const link = new OpenAPILink(contract, {
+  errorResponseContentType: 'application/problem+json',
+})
+```
+
 ## Error Responses
 
 When the server answers with an error, `OpenAPILink` throws an `ORPCError` whose `cause` is a `ResponseError` carrying the resolved response, so details that are not part of the error itself, such as its status or headers, stay available (errors returned by [`customErrorResponseBodyDecoder`](#custom-error-decoding) are thrown as-is):
 
@@ -257,3 +257,11 @@ const spec = await generator.generate(router, {
   },
 })
 ```
+
+If the handler sets [`errorResponseContentType`](/docs/openapi/handler#custom-error-response), pass the same value to the generator so error responses are documented under that media type:
+
+```ts
+const spec = await generator.generate(router, {
+  errorResponseContentType: 'application/problem+json',
+})
+```
@@ -978,6 +978,18 @@ describe('openAPIHandlerCodec', () => {
       expect(serializer.serialize).toHaveBeenNthCalledWith(2, secondError.toJSON())
     })
 
+    it('sets content-type header via errorResponseContentType option', () => {
+      const procedure = os.handler(vi.fn())
+      const codec = new OpenAPIHandlerCodec(procedure, { errorResponseContentType: 'application/problem+json' })
+      const error = new ORPCError('BAD_GATEWAY')
+
+      expect(codec.encodeError(error)).toEqual({
+        status: 502,
+        headers: { 'content-type': 'application/problem+json' },
+        body: error.toJSON(),
+      })
+    })
+
     it('does not resolve error codes through Object.prototype', async () => {
       const serializer = { serialize: vi.fn(), deserialize: vi.fn() } as any
       const codec = new OpenAPIHandlerCodec({ procedure: os.handler(vi.fn()) }, { serializer })
 
@@ -44,17 +44,26 @@ export interface OpenAPIHandlerCodecCoreOptions<_T extends Context> {
    * @default ((e) => e.toJSON())
    */
   customErrorResponseBodyEncoder?: ((error: AnyORPCError) => unknown) | undefined
+
+  /**
+   * The `content-type` of error responses, e.g. `application/problem+json` for RFC 9457 Problem Details.
+   *
+   * @default 'application/json'
+   */
+  errorResponseContentType?: string | undefined
 }
 
 export class OpenAPIHandlerCodecCore<T extends Context> {
   private readonly serializer: Public<OpenAPISerializer>
   private readonly errorStatusMap: Exclude<OpenAPIHandlerCodecOptions<T>['errorStatusMap'], undefined>
   private readonly customErrorResponseBodySerializer: OpenAPIHandlerCodecOptions<T>['customErrorResponseBodyEncoder']
+  private readonly errorResponseContentType: OpenAPIHandlerCodecOptions<T>['errorResponseContentType']
 
   constructor(options: OpenAPIHandlerCodecCoreOptions<T> = {}) {
     this.serializer = options.serializer ?? new OpenAPISerializer()
     this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP
     this.customErrorResponseBodySerializer = options.customErrorResponseBodyEncoder
+    this.errorResponseContentType = options.errorResponseContentType
   }
 
   async decodeInput(
@@ -140,7 +149,7 @@ export class OpenAPIHandlerCodecCore<T extends Context> {
 
     return {
       status,
-      headers: {},
+      headers: this.errorResponseContentType !== undefined ? { 'content-type': this.errorResponseContentType } : {},
       body: this.serializer.serialize(this.customErrorResponseBodySerializer?.(error) ?? error.toJSON()),
     }
   }
 
@@ -856,6 +856,22 @@ describe('openAPILinkCodec', () => {
       expectORPCErrorResult(result, 'NOT_FOUND')
     })
 
+    it.each([
+      ['a matching error', 404, 'application/problem+json', 'json'],
+      ['an error with different case and parameters', 404, 'Application/Problem+JSON; charset=utf-8', 'json'],
+      ['an error with another type', 502, 'text/html', undefined],
+      ['a successful response', 200, 'application/problem+json', 'file'],
+    ] as const)('resolves the body hint of %s with errorResponseContentType', async (_, status, contentType, hint) => {
+      const codec = new OpenAPILinkCodec({
+        ping: oc.meta(openapi({ responseBodyHint: 'file' })),
+      }, { serializer, errorResponseContentType: 'application/problem+json; charset=utf-8' })
+
+      const resolveBody = vi.fn(async () => new ORPCError('NOT_FOUND').toJSON())
+      await codec.decodeResponse({ status, headers: { 'content-type': contentType }, resolveBody }, ['ping'], { context: {} })
+
+      expect(resolveBody).toHaveBeenCalledWith(hint)
+    })
+
     it('throws MalformedResponseError on unknown error payloads', async () => {
       const codec = new OpenAPILinkCodec({
         ping: oc.meta(openapi({})),
 
@@ -8,7 +8,7 @@ import { createORPCErrorFromJson, isORPCErrorJson, MalformedResponseError, Respo
 import { getRouterContract, ProcedureContract } from '@orpc/contract'
 import { unlazy } from '@orpc/server'
 import { isTypescriptObject, mergeHttpPath, pathToHttpPath, safeEncodeURIComponent, stringifyJSON, value } from '@orpc/shared'
-import { mergeStandardHeaders, parseStandardUrl } from '@standard-server/core'
+import { flattenStandardHeader, mergeStandardHeaders, parseStandardUrl } from '@standard-server/core'
 import { toStandardHeaders } from '@standard-server/fetch'
 import {
   DEFAULT_OPENAPI_INPUT_STRUCTURE,
@@ -47,6 +47,14 @@ export interface OpenAPILinkCodecOptions<T extends ClientContext> {
     deserializedBody: unknown,
     response: StandardLazyResponse,
   ) => AnyORPCError | null | undefined) | undefined
+
+  /**
+   * Parse error responses with this `content-type` as JSON, ignoring case and parameters such as `charset`.
+   * Should match the handler's `errorResponseContentType`.
+   *
+   * @example 'application/problem+json'
+   */
+  errorResponseContentType?: string | undefined
 }
 
 const END_SLASH_REGEX = /\/$/
@@ -57,6 +65,7 @@ export class OpenAPILinkCodec<T extends ClientContext> implements StandardLinkCo
   private readonly headers: Exclude<OpenAPILinkCodecOptions<T>['headers'], undefined>
   private readonly serializer: Exclude<OpenAPILinkCodecOptions<T>['serializer'], undefined>
   private readonly customErrorResponseBodyDecoder: OpenAPILinkCodecOptions<T>['customErrorResponseBodyDecoder']
+  private readonly errorResponseMediaType: string | undefined
 
   constructor(
     private readonly router: RouterContract,
@@ -66,6 +75,7 @@ export class OpenAPILinkCodec<T extends ClientContext> implements StandardLinkCo
     this.headers = options.headers ?? {}
     this.serializer = options.serializer ?? new OpenAPISerializer()
     this.customErrorResponseBodyDecoder = options.customErrorResponseBodyDecoder
+    this.errorResponseMediaType = toMediaType(options.errorResponseContentType)
   }
 
   async encodeInput(input: unknown, path: string[], options: ClientOptions<T>): Promise<StandardRequest> {
@@ -382,7 +392,13 @@ export class OpenAPILinkCodec<T extends ClientContext> implements StandardLinkCo
     const procedure = await this.resolveProcedure(path)
     const meta = getOpenAPIMeta(procedure)
 
-    const body = await response.resolveBody(isOk ? meta?.responseBodyHint : undefined)
+    const errorBodyHint = !isOk
+      && this.errorResponseMediaType !== undefined
+      && toMediaType(flattenStandardHeader(response.headers['content-type'])) === this.errorResponseMediaType
+      ? 'json'
+      : undefined
+
+    const body = await response.resolveBody(isOk ? meta?.responseBodyHint : errorBodyHint)
 
     const deserialized = await (async () => {
       try {
@@ -457,6 +473,13 @@ function combineSearch(baseSearch: `?${string}` | undefined, additionalSearch: s
   return `${baseSearch}&${additionalSearch}` as `?${string}`
 }
 
+/**
+ * Strips parameters and normalizes case, e.g. `Application/Problem+JSON; charset=utf-8` -> `application/problem+json`.
+ */
+function toMediaType(contentType: string | undefined): string | undefined {
+  return contentType?.split(';')[0]?.trim().toLowerCase()
+}
+
 function toResolvedStandardHeaders(headers: Headers | StandardHeaders): StandardHeaders {
   /**
    * Headers class might not be available in some environments,
 
@@ -20,6 +20,7 @@ describe('openAPIGenerator operation builders', () => {
     schemas?: Record<string, any>
     errorStatusMap?: Record<string, number>
     customErrorResponseBodySchema?: OpenAPIOperationContext['customErrorResponseBodySchema']
+    errorResponseContentType?: string
   } = {}) {
     const doc: OpenAPIV3_2.OpenAPIObject = {
       openapi: '3.2.0',
@@ -45,6 +46,7 @@ describe('openAPIGenerator operation builders', () => {
       },
       errorStatusMap: options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP,
       customErrorResponseBodySchema: options.customErrorResponseBodySchema,
+      errorResponseContentType: options.errorResponseContentType ?? 'application/json',
     }
 
     const operation: OpenAPIV3_2.OperationObject = {}
@@ -934,5 +936,13 @@ describe('openAPIGenerator operation builders', () => {
         expect.objectContaining({ oneOf: expect.any(Array) }),
       )
     })
+
+    it('documents error bodies under the configured content type', () => {
+      const { ctx, operation } = createContext({ errorResponseContentType: 'application/problem+json' })
+
+      buildErrorResponse(ctx, operation, testDef({ errors: { NOT_FOUND: {} } }))
+
+      expect(Object.keys((operation.responses?.['404'] as any).content)).toEqual(['application/problem+json'])
+    })
   })
 })
@@ -49,6 +49,7 @@ export interface OpenAPIOperationContext {
     JsonSchema | undefined | null,
     [definedErrors: OpenAPIErrorBodyDefinition[], status: number]
   > | undefined
+  errorResponseContentType: string
 }
 
 export function toOpenAPIPath(path: `/${string}`, dynamicPathParams: DynamicPathParam[] | undefined): `/${string}` {
@@ -551,7 +552,7 @@ export function buildErrorResponse(
     operation.responses[toResponseStatusKey(status)] = {
       description: descriptions.length ? descriptions.join(', ') : status.toString(),
       content: {
-        'application/json': {
+        [ctx.errorResponseContentType]: {
           schema: ctx.registry.toOpenAPISchema(responseSchema, 'output'),
         },
       },
 
@@ -85,6 +85,14 @@ export interface OpenAPIGeneratorGenerateOptions<TVersion extends OpenAPIVersion
     [definedErrors: OpenAPIErrorBodyDefinition[], status: number]
   > | undefined
 
+  /**
+   * Media type of error responses in the generated document, e.g. `application/problem+json`.
+   * Should match the handler's `errorResponseContentType`.
+   *
+   * @default 'application/json'
+   */
+  errorResponseContentType?: string | undefined
+
   /**
    * Mapping ORPCError Code -> HTTP Status Code
    * Codes missing from the map fall back to `DEFAULT_ERROR_STATUS` (400).
@@ -129,6 +137,7 @@ export class OpenAPIGenerator {
       convertSchemas: (schemas, direction) => this.convertSchemas(schemas, direction),
       errorStatusMap: options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP,
       customErrorResponseBodySchema: options.customErrorResponseBodySchema,
+      errorResponseContentType: options.errorResponseContentType ?? 'application/json',
     }
 
     const errors: string[] = []