diff --git a/.rubocop.yml b/.rubocop.yml
index f5efca2..0544a6b 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -41,11 +41,29 @@ Style/OneClassPerFile:
     - "lib/docs_kit.rb"
 
 # The shell head/page templates are linear builders; their ABC is inherent to the
-# markup they emit, not accidental complexity.
+# markup they emit, not accidental complexity. Configuration#initialize is a flat
+# list of default assignments (one per knob) — its ABC is the knob count, not
+# branching complexity.
 Metrics/AbcSize:
   Exclude:
     - "app/components/docs_ui/shell.rb"
     - "app/components/docs_ui/page.rb"
+    - "lib/docs_kit/configuration.rb"
+
+# ApiRequest/ApiClient are Data value objects and RequestExample is a public
+# component; their keyword-arg constructors mirror the documented API (method:,
+# path:, body:, query:, headers:, clients:), which is inherently wide.
+Metrics/ParameterLists:
+  Exclude:
+    - "lib/docs_kit/api_request.rb"
+    - "app/components/docs_ui/request_example.rb"
+
+# ApiRequest deliberately names a member `method:` — it IS the HTTP method, the
+# documented public field templates read as `request.method`. The shadowing of
+# Object#method is intended (no reflection is done on the struct).
+Lint/DataDefineOverride:
+  Exclude:
+    - "lib/docs_kit/api_request.rb"
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes
@@ -61,10 +79,13 @@ Metrics/BlockLength:
     - "lib/docs_kit/templates/**/*"
 
 # Generators are procedural wiring — one method per install step — so they're
-# naturally long and flat, not complex.
+# naturally long and flat, not complex. Configuration is the per-site config
+# surface: one accessor + one default per knob, plus small derived readers — its
+# length is the knob count, not accidental complexity.
 Metrics/ClassLength:
   Exclude:
     - "lib/generators/**/*"
+    - "lib/docs_kit/configuration.rb"
 
 Metrics/MethodLength:
   Max: 25
diff --git a/README.md b/README.md
index d3e354f..eb326ba 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,8 @@ A `DocsUI::` Phlex kit, configured once per site:
 | `DocsUI::Table` / `PropTable` | Reference tables — generic headers+rows, and a name/type/default/description preset. |
 | `DocsUI::Endpoint` | HTTP method badge (coloured per verb) + monospace path; renders inline (drops into a `Section` description). |
 | `DocsUI::FieldTable` / `ErrorTable` | API-reference presets over `Table` — an object's fields, and an endpoint's errors (Param column auto-hidden when unused). |
+| `DocsUI::RequestExample` | One request declaration → one code tab per configured client (curl / JS / Ruby / Python by default). |
+| `DocsUI::JsonResponse` | A Ruby Hash (or String) rendered as a pretty-printed JSON response block. |
 | `DocsUI::Example` | Base for a live example with `method_source`-extracted source. |
 
 Plus `DocsKit::Registry` (in-memory docs registry mixin), `DocsKit::NavItem`
@@ -240,6 +242,70 @@ this page" TOC still come from `DocsUI::Section`** — keep section titles as
 `Section`, and use Markdown headings only for sub-headings inside a section. Raw
 HTML in the Markdown source is dropped (no `<script>`, no passthrough).
 
+## API docs — one request, every client tab
+
+An endpoint example is a request shown in several clients (curl, JavaScript,
+Ruby, Python, …) plus a JSON response. Writing each client by hand means a field
+rename edits every language. `DocsUI::RequestExample` derives all the tabs from
+**one** declaration; `DocsUI::JsonResponse` renders a Ruby Hash as a
+pretty-printed response block.
+
+```ruby
+def content
+  DocsUI::Section("Create a payment link",
+    description: DocsUI::Endpoint.new(:post, "/v1/payment_links")) do
+
+    render DocsUI::RequestExample.new(
+      method: :post,
+      path:   "/v1/payment_links",
+      body:   { amount: 4900, currency: "usd", description: "Pro plan" }
+    )
+
+    render DocsUI::JsonResponse.new(
+      { id: "plink_1a2b3c", object: "payment_link", amount: 4900,
+        currency: "usd", url: "https://pay.example.com/plink_1a2b3c" }
+    )
+  end
+end
+```
+
+`RequestExample` renders a `DocsUI::Example`, so the global sticky language
+choice works exactly as with a hand-built example (pick Ruby once, every request
+on the site shows Ruby). With JS off, every client snippet is visible stacked.
+
+**Configure the client set and host once:**
+
+```ruby
+# config/initializers/docs_kit.rb
+DocsKit.configure do |c|
+  c.api_base_url   = "https://api.acme.com"                 # prefixed onto every path
+  c.api_auth_header = "Authorization: Bearer sk_live_..."   # nil ⇒ no auth line
+
+  # Swap a default for an SDK-flavored snippet, or add a new tab (e.g. a CLI):
+  c.api_clients = {
+    ruby: DocsKit::ApiClient.new(
+      label: "Ruby", lexer: :ruby, filename: "app.rb",
+      template: ->(req) { %(Acme.new.payment_links.create(#{req.pretty_body_json})) }
+    ),
+    cli: DocsKit::ApiClient.new(
+      label: "CLI", lexer: :shell, filename: "acme",
+      template: ->(req) { "acme payment_links create --amount #{req.body[:amount]}" }
+    )
+  }
+end
+```
+
+The gem ships four generic-HTTP clients (`curl`, `javascript`, `ruby`,
+`python`). A `c.api_clients` entry merges **over** them: reuse a token
+(`ruby`) to replace that client with your SDK's snippet, or use a new token
+(`cli`) to append a tab. Order is stable — reused tokens keep their position, new
+ones append. Each `template` is a `(DocsKit::ApiRequest) -> String` callable;
+the request exposes `#http_method`, `#url`, `#url_with_query`, `#headers`,
+`#body?`, and `#pretty_body_json` so a template stays one short heredoc.
+
+Pass `clients:` to a single call to filter/order the tabs:
+`DocsUI::RequestExample.new(method: :get, path: "/v1/things", clients: [:curl, :ruby])`.
+
 ## Scaffold a new docs site in one command
 
 ```bash
diff --git a/app/components/docs_ui/example.rb b/app/components/docs_ui/example.rb
index b62c53a..460c74a 100644
--- a/app/components/docs_ui/example.rb
+++ b/app/components/docs_ui/example.rb
@@ -31,13 +31,15 @@ def initialize
     # Collect one language's snippet. `lang` is the language token (e.g. :ruby,
     # :python, :go) — Docs::Code resolves it against Rouge's full registry + the
     # configured aliases, so any language works. The tab label comes from the
-    # configured language_labels (else the token capitalized). filename/lexer are
-    # optional; lexer defaults to the language token. The block returns the source.
-    def code(lang, filename: nil, lexer: nil)
+    # configured language_labels (else the token capitalized), or an explicit
+    # `label:` override (used by RequestExample so a client carries its own tab
+    # name). filename/lexer are optional; lexer defaults to the language token.
+    # The block returns the source.
+    def code(lang, filename: nil, lexer: nil, label: nil)
       token = lang.to_sym
       @snippets << {
         lang: token,
-        label: DocsKit.configuration.language_labels.fetch(token, token.to_s.capitalize),
+        label: label || DocsKit.configuration.language_labels.fetch(token, token.to_s.capitalize),
         filename: filename,
         lexer: lexer || token,
         source: yield.to_s
diff --git a/app/components/docs_ui/json_response.rb b/app/components/docs_ui/json_response.rb
new file mode 100644
index 0000000..3531955
--- /dev/null
+++ b/app/components/docs_ui/json_response.rb
@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "json"
+
+module DocsUI
+  # A pretty-printed JSON response block. Give it a Ruby Hash (deep-stringified and
+  # JSON.pretty_generate'd) or a pre-formatted String; it renders a DocsUI::Code
+  # with the json lexer and a filename title bar. Kills the hand-rolled
+  # deep_stringify + JSON.pretty_generate every API page was copy-pasting.
+  #
+  #   render DocsUI::JsonResponse.new({ id: "obj_1", status: "active" })
+  #   render DocsUI::JsonResponse.new(raw_json_string, filename: "webhook.json")
+  #
+  # A Hash with symbol keys renders as real JSON (string keys, no :symbol / =>
+  # leaking through). A String is passed through verbatim (already formatted).
+  class JsonResponse < Phlex::HTML
+    def initialize(body, filename: "response.json")
+      @body = body
+      @filename = filename
+    end
+
+    def view_template
+      render DocsUI::Code.new(json_source, lexer: :json, filename: @filename)
+    end
+
+    private
+
+    # The JSON string to highlight: a String passes through; a Hash/Array is
+    # deep-stringified then pretty-generated so it reads like an API response.
+    def json_source
+      return @body if @body.is_a?(String)
+
+      JSON.pretty_generate(deep_stringify(@body))
+    end
+
+    # Recursively stringify keys and symbol values so the output is real JSON.
+    def deep_stringify(value)
+      case value
+      when Hash then value.to_h { |k, v| [k.to_s, deep_stringify(v)] }
+      when Array then value.map { |v| deep_stringify(v) }
+      when Symbol then value.to_s
+      else value
+      end
+    end
+  end
+end
diff --git a/app/components/docs_ui/request_example.rb b/app/components/docs_ui/request_example.rb
new file mode 100644
index 0000000..077c5eb
--- /dev/null
+++ b/app/components/docs_ui/request_example.rb
@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module DocsUI
+  # One structured request declaration → one code tab per configured API client.
+  # Declare method/path/body once and every client (curl, javascript, ruby,
+  # python by default; plus whatever a site adds) renders its own snippet, in a
+  # DocsUI::Example so the sticky global language preference keeps working.
+  #
+  #   render DocsUI::RequestExample.new(
+  #     method: :post, path: "/v1/webhook_endpoints",
+  #     body: { url: "https://example.com/hook", events: ["payment.paid"] }
+  #   )
+  #
+  #   # only some tabs, in a chosen order:
+  #   render DocsUI::RequestExample.new(method: :get, path: "/v1/things", clients: %i[curl ruby])
+  #
+  # The base URL and an example auth header come from config
+  # (DocsKit.configuration.api_base_url / #api_auth_header); the client set comes
+  # from #api_clients (defaults + site overrides). This replaces the per-client
+  # heredoc a docs page used to hand-write once per endpoint per language.
+  class RequestExample < Phlex::HTML
+    def initialize(method:, path:, body: nil, query: nil, headers: {}, clients: nil)
+      @method = method
+      @path = path
+      @body = body
+      @query = query || {}
+      @headers = headers || {}
+      @clients = clients
+    end
+
+    def view_template
+      request = build_request
+      selected = selected_clients
+
+      render DocsUI::Example.new do |ex|
+        selected.each do |token, client|
+          ex.code(
+            token,
+            lexer: client.lexer,
+            label: client.label,
+            filename: client.filename_for(request)
+          ) { client.render(request) }
+        end
+      end
+    end
+
+    private
+
+    # The request struct handed to every client template: config base URL + path,
+    # config auth header merged into the headers.
+    def build_request
+      config = DocsKit.configuration
+      DocsKit::ApiRequest.new(
+        method: @method,
+        path: @path,
+        url: "#{config.api_base_url}#{@path}",
+        query: @query,
+        headers: merged_headers(config.api_auth_header),
+        body: @body
+      )
+    end
+
+    # The site's example Authorization header (if any) merged into the per-request
+    # headers. The header line is "Name: value"; split it into a { name => value }
+    # entry so templates can format it per language.
+    def merged_headers(auth_header)
+      return @headers if auth_header.nil? || auth_header.strip.empty?
+
+      name, value = auth_header.split(":", 2).map(&:strip)
+      { name => value }.merge(@headers)
+    end
+
+    # The { token => ApiClient } tabs to render, in order: the configured full map,
+    # or just the requested `clients:` tokens (in the given order), skipping any
+    # unknown token so a typo degrades to fewer tabs rather than raising.
+    def selected_clients
+      configured = DocsKit.configuration.api_clients
+      return configured if @clients.nil?
+
+      @clients.filter_map { |token| [token.to_sym, configured[token.to_sym]] if configured.key?(token.to_sym) }.to_h
+    end
+  end
+end
diff --git a/docs/app/views/docs/pages/components.rb b/docs/app/views/docs/pages/components.rb
index cff7746..6d669b2 100644
--- a/docs/app/views/docs/pages/components.rb
+++ b/docs/app/views/docs/pages/components.rb
@@ -22,6 +22,7 @@ def content
           example_section
           table_section
           endpoint_section
+          request_example_section
           callout_section
           icon_section
           on_this_page_section
@@ -404,6 +405,110 @@ def endpoint_section
           end
         end
 
+        def request_example_section
+          DocsUI::Section(
+            "RequestExample & JsonResponse",
+            description: "The API-docs kit — declare a request once, get every client tab; render a Ruby hash as a JSON response."
+          ) do
+            prose do
+              p do
+                code { "DocsUI::RequestExample" }
+                plain " turns one structured request declaration ("
+                code { "method:" }
+                plain "/"
+                code { "path:" }
+                plain "/"
+                code { "body:" }
+                plain ") into a "
+                code { "DocsUI::Example" }
+                plain " with one tab per configured client — "
+                code { "curl" }
+                plain ", "
+                code { "javascript" }
+                plain ", "
+                code { "ruby" }
+                plain ", "
+                code { "python" }
+                plain " by default (a site adds its own, e.g. a "
+                code { "cli" }
+                plain " tab). "
+                code { "DocsUI::JsonResponse" }
+                plain " renders a Ruby Hash as pretty-printed JSON — no hand-rolled "
+                code { "deep_stringify" }
+                plain "."
+              end
+            end
+
+            # Live: one declaration → four client tabs, plus a JSON response.
+            DocsUI::Section(
+              "Create a payment link",
+              description: DocsUI::Endpoint.new(:post, "/v1/payment_links")
+            ) do
+              prose { p { "Creates a shareable payment link for a fixed amount." } }
+              render DocsUI::FieldTable.new(
+                [
+                  { name: "amount", type: "integer", required: true, description: "Amount in the smallest currency unit." },
+                  { name: "currency", type: "string", required: true, description: "ISO 4217 currency code." },
+                  { name: "description", type: "string", description: "Shown to the payer at checkout." }
+                ]
+              )
+              render DocsUI::RequestExample.new(
+                method: :post,
+                path: "/v1/payment_links",
+                body: { amount: 4900, currency: "usd", description: "Pro plan" }
+              )
+              prose { p { "A successful response:" } }
+              render DocsUI::JsonResponse.new(
+                {
+                  id: "plink_1a2b3c",
+                  object: "payment_link",
+                  amount: 4900,
+                  currency: "usd",
+                  url: "https://pay.example.com/plink_1a2b3c",
+                  active: true
+                }
+              )
+            end
+
+            prose { p { "The calls that produced the block above:" } }
+            DocsUI::Code(<<~RUBY)
+              render DocsUI::RequestExample.new(
+                method: :post,
+                path: "/v1/payment_links",
+                body: { amount: 4900, currency: "usd", description: "Pro plan" }
+              )
+              render DocsUI::JsonResponse.new(
+                { id: "plink_1a2b3c", object: "payment_link", amount: 4900,
+                  currency: "usd", url: "https://pay.example.com/plink_1a2b3c", active: true }
+              )
+            RUBY
+
+            DocsUI::Callout(:tip) do
+              plain "The client set, base URL, and example auth header are config: "
+              code { "c.api_clients" }
+              plain " (defaults + your overrides), "
+              code { "c.api_base_url" }
+              plain ", and "
+              code { "c.api_auth_header" }
+              plain ". Override a default token to swap in an SDK-flavored snippet; add a new token (e.g. "
+              code { "cli" }
+              plain ") to append a tab."
+            end
+
+            render DocsUI::PropTable.new(
+              [
+                [ "RequestExample method:/path:", "Symbol/String, String", "—", "The HTTP verb and path (path is appended to c.api_base_url)." ],
+                [ "RequestExample body:", "Hash, nil", "nil", "Request payload; deep-stringified into each snippet. Omit for a GET." ],
+                [ "RequestExample query:/headers:", "Hash", "{}", "Query params and extra headers merged into every snippet." ],
+                [ "RequestExample clients:", "Array<Symbol>, nil", "all configured", "Filter/order the tabs (e.g. [:curl, :ruby])." ],
+                [ "JsonResponse.new(body)", "Hash or String", "—", "Hash → pretty JSON with string keys; String → passed through." ],
+                [ "JsonResponse filename:", "String", '"response.json"', "The code block's title-bar filename." ]
+              ],
+              headers: [ "Call", "Type", "Default", "Description" ]
+            )
+          end
+        end
+
         def callout_section
           DocsUI::Section("Callout", description: "note / tip / warning — a daisyUI alert with a lucide icon.") do
             DocsUI::Callout(:note) { "This is a note callout." }
diff --git a/lib/docs_kit/api_client.rb b/lib/docs_kit/api_client.rb
new file mode 100644
index 0000000..06b6357
--- /dev/null
+++ b/lib/docs_kit/api_client.rb
@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module DocsKit
+  # One API-example language tab: a label, a Rouge lexer, a filename (a String or
+  # a `(request) -> String` proc), and a `template` — a `(DocsKit::ApiRequest) ->
+  # String` callable that renders the snippet. DocsUI::RequestExample turns each
+  # configured client into one DocsUI::Example tab.
+  #
+  #   DocsKit::ApiClient.new(
+  #     label: "cURL", lexer: :curl, filename: "request.sh",
+  #     template: ->(req) { "curl -X #{req.http_method} '#{req.url}'" }
+  #   )
+  #
+  # The gem ships four generic-HTTP defaults (DEFAULTS); a site overrides or
+  # extends them via DocsKit.configuration.api_clients (SDK-flavored snippets, a
+  # `cli` tab, ...).
+  ApiClient = Data.define(:label, :lexer, :filename, :template) do
+    def initialize(label:, lexer:, template:, filename: nil)
+      super
+    end
+
+    # The filename for this client's title bar: a static String, or the result of
+    # calling a proc filename with the request (so it can vary by verb/path).
+    def filename_for(request)
+      filename.respond_to?(:call) ? filename.call(request) : filename
+    end
+
+    # Render the snippet for this client from the request struct.
+    def render(request) = template.call(request)
+  end
+
+  # The four generic-HTTP clients every site starts from. Order is stable
+  # (curl → javascript → ruby → python) and preserved when a site merges its own.
+  ApiClient::DEFAULTS = {
+    curl: ApiClient.new(
+      label: "cURL", lexer: :curl, filename: "request.sh",
+      template: ApiTemplates.method(:curl)
+    ),
+    javascript: ApiClient.new(
+      label: "JavaScript", lexer: :javascript, filename: "request.js",
+      template: ApiTemplates.method(:javascript)
+    ),
+    ruby: ApiClient.new(
+      label: "Ruby", lexer: :ruby, filename: "request.rb",
+      template: ApiTemplates.method(:ruby)
+    ),
+    python: ApiClient.new(
+      label: "Python", lexer: :python, filename: "request.py",
+      template: ApiTemplates.method(:python)
+    )
+  }.freeze
+end
diff --git a/lib/docs_kit/api_request.rb b/lib/docs_kit/api_request.rb
new file mode 100644
index 0000000..6a95d6c
--- /dev/null
+++ b/lib/docs_kit/api_request.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+
+module DocsKit
+  # A single API request, declared once and handed to every client template so a
+  # snippet is authored one place, not per language. DocsUI::RequestExample builds
+  # one from its args (merging DocsKit.configuration.api_base_url + the auth header)
+  # and each DocsKit::ApiClient#template receives it.
+  #
+  #   req = DocsKit::ApiRequest.new(
+  #     method: :post, path: "/v1/things",
+  #     url: "https://api.example.com/v1/things",
+  #     body: { name: "Acme" }
+  #   )
+  #   req.http_method       # => "POST"
+  #   req.pretty_body_json  # => %({\n  "name": "Acme"\n})
+  #
+  # Templates stay one short heredoc each: they read #http_method, #url,
+  # #url_with_query, #headers, #body?, and #pretty_body_json.
+  ApiRequest = Data.define(:method, :path, :url, :query, :headers, :body) do
+    def initialize(method:, path:, url:, query: {}, headers: {}, body: nil)
+      super
+    end
+
+    # The upcased HTTP verb for display in a snippet ("POST", "GET", ...).
+    def http_method = method.to_s.upcase
+
+    # Whether the request carries a payload body (drives whether a template emits
+    # its payload lines at all).
+    def body? = !body.nil?
+
+    # The body as pretty-printed JSON with string keys (deep-stringified), or nil
+    # when there is no body. A String body is passed through unchanged.
+    def pretty_body_json
+      return nil unless body?
+      return body if body.is_a?(String)
+
+      JSON.pretty_generate(deep_stringify(body))
+    end
+
+    # A URL-encoded "?a=1&b=2" query string, or "" when there is no query.
+    def query_string
+      return "" if query.nil? || query.empty?
+
+      "?#{URI.encode_www_form(query)}"
+    end
+
+    # The URL with the query string appended (the copy-pasteable request target).
+    def url_with_query = "#{url}#{query_string}"
+
+    private
+
+    # Recursively stringify Hash/Array keys and symbol values so JSON output reads
+    # like a real API response (no Ruby :symbol / => syntax leaking through).
+    def deep_stringify(value)
+      case value
+      when Hash then value.to_h { |k, v| [k.to_s, deep_stringify(v)] }
+      when Array then value.map { |v| deep_stringify(v) }
+      when Symbol then value.to_s
+      else value
+      end
+    end
+  end
+end
diff --git a/lib/docs_kit/api_templates.rb b/lib/docs_kit/api_templates.rb
new file mode 100644
index 0000000..06e4d40
--- /dev/null
+++ b/lib/docs_kit/api_templates.rb
@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module DocsKit
+  # The four generic-HTTP snippet templates the gem ships (curl, fetch, Net::HTTP,
+  # requests). Each is a `(DocsKit::ApiRequest) -> String` callable, referenced by
+  # DocsKit::ApiClient::DEFAULTS.
+  #
+  # The gem intentionally ships GENERIC HTTP snippets — it cannot know a site's
+  # SDK. A site swaps in SDK-flavored templates (or adds a `cli` client) by
+  # overriding c.api_clients; these are the fallback every site starts from.
+  #
+  # Every template guards its payload lines on request.body? so a body-less GET
+  # renders no dangling `-d`/`json=`/`request.body =` line.
+  module ApiTemplates
+    module_function
+
+    # curl -X METHOD 'url' [-H "Header: v"]... [-d '{json}']
+    def curl(request)
+      lines = ["curl -X #{request.http_method} '#{request.url_with_query}'"]
+      request.headers.each { |name, value| lines << %(  -H "#{name}: #{value}") }
+      lines << %(  -H "Content-Type: application/json") if request.body?
+      lines << "  -d '#{request.pretty_body_json}'" if request.body?
+      lines.join(" \\\n")
+    end
+
+    # A fetch() call with a headers object and an optional JSON body.
+    def javascript(request)
+      headers = { "Content-Type" => "application/json" }.merge(request.headers)
+      header_lines = headers.map { |k, v| %(    "#{k}": "#{v}") }.join(",\n")
+      body_line = request.body? ? %(\n  body: JSON.stringify(#{compact_json(request)}),) : ""
+
+      <<~JS.strip
+        const response = await fetch("#{request.url_with_query}", {
+          method: "#{request.http_method}",
+          headers: {
+        #{header_lines}
+          },#{body_line}
+        });
+        const data = await response.json();
+      JS
+    end
+
+    # A Net::HTTP snippet: build the request, set headers, optional JSON body, send.
+    def ruby(request)
+      header_lines = request.headers.map { |k, v| %(request["#{k}"] = "#{v}") }
+      body_line = request.body? ? %(request.body = #{request.pretty_body_json}.to_json) : nil
+
+      <<~RUBY.strip
+        require "net/http"
+        require "json"
+
+        uri = URI("#{request.url_with_query}")
+        request = Net::HTTP::#{request.http_method.capitalize}.new(uri)
+        request["Content-Type"] = "application/json"
+        #{[*header_lines, body_line].compact.join("\n")}
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.request(request)
+        end
+      RUBY
+    end
+
+    # A requests.<verb>(url, headers=..., json=...) call. Pretty JSON with
+    # double-quoted keys is valid Python dict syntax, so it drops straight into json=.
+    def python(request)
+      headers = { "Content-Type" => "application/json" }.merge(request.headers)
+      header_repr = headers.map { |k, v| %("#{k}": "#{v}") }.join(", ")
+      json_arg = request.body? ? ", json=#{request.pretty_body_json}" : ""
+
+      <<~PY.strip
+        import requests
+
+        response = requests.#{request.method.to_s.downcase}(
+            "#{request.url_with_query}",
+            headers={#{header_repr}}#{json_arg},
+        )
+        data = response.json()
+      PY
+    end
+
+    # --- helpers ------------------------------------------------------------
+
+    # The body as compact single-line JSON, for inlining in a JS literal.
+    def compact_json(request)
+      require "json"
+      JSON.generate(JSON.parse(request.pretty_body_json))
+    end
+  end
+end
diff --git a/lib/docs_kit/configuration.rb b/lib/docs_kit/configuration.rb
index 0d19bc0..c83ddfc 100644
--- a/lib/docs_kit/configuration.rb
+++ b/lib/docs_kit/configuration.rb
@@ -95,6 +95,23 @@ class Configuration
     # (e.g. { elixir: "Elixir", curl: "cURL" }). Unknown tokens humanize.
     attr_accessor :code_language_labels
 
+    # The API base URL prefixed onto a DocsUI::RequestExample path so copy-pasted
+    # snippets point at a real host. Defaults to a neutral example host; a site
+    # sets its own (e.g. "https://api.acme.com").
+    attr_accessor :api_base_url
+
+    # An example Authorization header line merged into every generated request
+    # snippet (e.g. "Authorization: Bearer sk_live_..."). Defaults to nil → no
+    # auth line, so a site with no auth example renders clean snippets.
+    attr_accessor :api_auth_header
+
+    # Site overrides/extensions for the DocsUI::RequestExample client tabs — an
+    # ordered { token => DocsKit::ApiClient } Hash merged OVER the four shipped
+    # defaults (curl, javascript, ruby, python). Reusing a default token replaces
+    # that client (SDK-flavored snippet); a new token appends a tab (e.g. a `cli`).
+    # Read the effective map via #api_clients (which merges), never @api_clients.
+    attr_writer :api_clients
+
     # The sentinel "no explicit nav" lambda. #nav_groups compares against this
     # identity to decide whether to derive the sidebar from #nav_registries.
     DEFAULT_NAV = -> { {} }
@@ -129,6 +146,17 @@ def initialize
       @code_lexer_aliases = {}
       @code_lexer_fallback = "plaintext"
       @code_language_labels = {}
+      @api_base_url = "https://api.example.com"
+      @api_auth_header = nil
+      @api_clients = {}
+    end
+
+    # The effective client map for DocsUI::RequestExample: the four shipped
+    # defaults with site overrides/extensions merged over them. Hash#merge keeps
+    # a reused token in its original position and appends new tokens in
+    # declaration order, so tab order is stable and predictable.
+    def api_clients
+      DocsKit::ApiClient::DEFAULTS.merge(@api_clients || {})
     end
 
     # The effective alias map (built-ins + site overrides), symbol-keyed.
diff --git a/spec/docs_kit/api_client_spec.rb b/spec/docs_kit/api_client_spec.rb
new file mode 100644
index 0000000..b369fe1
--- /dev/null
+++ b/spec/docs_kit/api_client_spec.rb
@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+RSpec.describe DocsKit::ApiClient do
+  def request(**overrides)
+    DocsKit::ApiRequest.new(method: :get, path: "/v1/things", url: "https://api.example.com/v1/things", **overrides)
+  end
+
+  it "carries label/lexer/filename/template" do
+    client = described_class.new(label: "cURL", lexer: :curl, filename: "request.sh", template: ->(_r) { "curl" })
+    expect(client.label).to eq("cURL")
+    expect(client.lexer).to eq(:curl)
+    expect(client.filename).to eq("request.sh")
+    expect(client.template).to respond_to(:call)
+  end
+
+  it "defaults filename to nil" do
+    expect(described_class.new(label: "X", lexer: :ruby, template: ->(_r) { "" }).filename).to be_nil
+  end
+
+  describe "#filename_for" do
+    it "returns a static string filename verbatim" do
+      client = described_class.new(label: "cURL", lexer: :curl, filename: "request.sh", template: ->(_r) { "" })
+      expect(client.filename_for(request)).to eq("request.sh")
+    end
+
+    it "calls a proc filename with the request" do
+      client = described_class.new(
+        label: "cURL", lexer: :curl,
+        filename: ->(req) { "#{req.http_method.downcase}.sh" }, template: ->(_r) { "" }
+      )
+      expect(client.filename_for(request(method: :post))).to eq("post.sh")
+    end
+  end
+
+  describe "#render" do
+    it "runs the template against the request" do
+      client = described_class.new(
+        label: "cURL", lexer: :curl,
+        template: ->(req) { "curl #{req.url}" }
+      )
+      expect(client.render(request)).to eq("curl https://api.example.com/v1/things")
+    end
+  end
+
+  describe "the four shipped defaults" do
+    def render_default(token, **request_overrides)
+      DocsKit::ApiClient::DEFAULTS.fetch(token).render(request(**request_overrides))
+    end
+
+    it "curl emits the method, url and (with a body) a -d payload" do
+      out = render_default(:curl, method: :post, body: { name: "Acme" },
+                                  url: "https://api.example.com/v1/things")
+      expect(out).to include("curl -X POST")
+      expect(out).to include("https://api.example.com/v1/things")
+      expect(out).to include("-d '")
+      expect(out).to include('"name": "Acme"')
+    end
+
+    it "curl omits the -d payload for a body-less GET" do
+      out = render_default(:curl)
+      expect(out).not_to include("-d ")
+      expect(out).to include("https://api.example.com/v1/things")
+    end
+
+    it "curl adds an -H auth header line when the request carries one" do
+      out = render_default(:curl, headers: { "Authorization" => "Bearer sk_live_..." })
+      expect(out).to include('-H "Authorization: Bearer sk_live_..."')
+    end
+
+    it "javascript emits a fetch call, with a JSON body only when present" do
+      with_body = render_default(:javascript, method: :post, body: { name: "Acme" })
+      expect(with_body).to include("fetch(")
+      expect(with_body).to include("method: \"POST\"")
+      expect(with_body).to include("body: JSON.stringify(")
+
+      without_body = render_default(:javascript)
+      expect(without_body).to include("fetch(")
+      expect(without_body).not_to include("body: JSON.stringify(")
+    end
+
+    it "ruby emits a Net::HTTP snippet, with a request body only when present" do
+      with_body = render_default(:ruby, method: :post, body: { name: "Acme" })
+      expect(with_body).to include("Net::HTTP")
+      expect(with_body).to include("request.body =")
+
+      without_body = render_default(:ruby)
+      expect(without_body).to include("Net::HTTP")
+      expect(without_body).not_to include("request.body =")
+    end
+
+    it "python emits a requests call, passing json= only when a body is present" do
+      with_body = render_default(:python, method: :post, body: { name: "Acme" })
+      expect(with_body).to include("import requests")
+      expect(with_body).to include("requests.post(")
+      expect(with_body).to include("json=")
+
+      without_body = render_default(:python)
+      expect(without_body).to include("requests.get(")
+      expect(without_body).not_to include("json=")
+    end
+  end
+end
diff --git a/spec/docs_kit/api_request_spec.rb b/spec/docs_kit/api_request_spec.rb
new file mode 100644
index 0000000..2598d15
--- /dev/null
+++ b/spec/docs_kit/api_request_spec.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+RSpec.describe DocsKit::ApiRequest do
+  def build(**overrides)
+    described_class.new(method: :get, path: "/v1/things",
+                        url: "https://api.example.com/v1/things", **overrides)
+  end
+
+  it "carries method/path/url and optional query/headers/body" do
+    req = build
+    expect(req.method).to eq(:get)
+    expect(req.path).to eq("/v1/things")
+    expect(req.url).to eq("https://api.example.com/v1/things")
+    expect(req.query).to eq({})
+    expect(req.headers).to eq({})
+    expect(req.body).to be_nil
+  end
+
+  it "upcases the HTTP method for display" do
+    expect(build(method: :post).http_method).to eq("POST")
+    expect(build(method: "patch").http_method).to eq("PATCH")
+  end
+
+  describe "#body?" do
+    it "is false with no body" do
+      expect(build.body?).to be(false)
+    end
+
+    it "is true when a body hash is present" do
+      expect(build(method: :post, body: { name: "x" }).body?).to be(true)
+    end
+  end
+
+  describe "#pretty_body_json" do
+    it "is nil when there is no body" do
+      expect(build.pretty_body_json).to be_nil
+    end
+
+    it "deep-stringifies symbol keys and pretty-prints" do
+      req = build(method: :post, body: { name: "Acme", nested: { count: 2 } })
+      json = req.pretty_body_json
+
+      expect(json).to include('"name": "Acme"')
+      expect(json).to include('"nested": {')
+      expect(json).to include('"count": 2')
+      # pretty_generate uses two-space indentation across lines.
+      expect(json).to include("\n  ")
+    end
+
+    it "deep-stringifies nested arrays and symbol values" do
+      req = build(method: :post, body: { events: %i[payment_link_paid refund_created] })
+      json = req.pretty_body_json
+
+      expect(json).to include('"payment_link_paid"') # symbol → JSON string
+      expect(json).to include('"refund_created"')
+      expect(json).not_to include(":payment_link_paid") # no Ruby symbol leaking
+    end
+
+    it "passes a String body through unchanged (already formatted)" do
+      req = build(method: :post, body: %({"a": 1}))
+      expect(req.pretty_body_json).to eq(%({"a": 1}))
+    end
+  end
+
+  describe "#query_string" do
+    it "is empty when there is no query" do
+      expect(build.query_string).to eq("")
+    end
+
+    it "renders a URL-encoded ?key=value string" do
+      req = build(query: { limit: 10, cursor: "a b" })
+      expect(req.query_string).to eq("?limit=10&cursor=a+b")
+    end
+  end
+
+  describe "#url_with_query" do
+    it "returns the bare url with no query" do
+      expect(build.url_with_query).to eq("https://api.example.com/v1/things")
+    end
+
+    it "appends the encoded query string" do
+      expect(build(query: { limit: 10 }).url_with_query).to eq("https://api.example.com/v1/things?limit=10")
+    end
+  end
+end
diff --git a/spec/docs_kit/configuration_spec.rb b/spec/docs_kit/configuration_spec.rb
index 5cee90e..cb7eabb 100644
--- a/spec/docs_kit/configuration_spec.rb
+++ b/spec/docs_kit/configuration_spec.rb
@@ -68,4 +68,61 @@ def self.nav_items
       expect(described_class.new.nav_groups).to eq({})
     end
   end
+
+  describe "#api_base_url" do
+    it "defaults to a neutral example host" do
+      expect(described_class.new.api_base_url).to eq("https://api.example.com")
+    end
+
+    it "is overridable so a site points snippets at its own host" do
+      DocsKit.configure { |c| c.api_base_url = "https://api.acme.test" }
+
+      expect(DocsKit.configuration.api_base_url).to eq("https://api.acme.test")
+    end
+  end
+
+  describe "#api_auth_header" do
+    it "defaults to nil (no auth line in generated snippets)" do
+      expect(described_class.new.api_auth_header).to be_nil
+    end
+
+    it "is overridable with the site's example Authorization header" do
+      DocsKit.configure { |c| c.api_auth_header = "Authorization: Bearer sk_live_..." }
+
+      expect(DocsKit.configuration.api_auth_header).to eq("Authorization: Bearer sk_live_...")
+    end
+  end
+
+  describe "#api_clients" do
+    it "ships four default clients in a stable order" do
+      expect(described_class.new.api_clients.keys).to eq(%i[curl javascript ruby python])
+    end
+
+    it "exposes each default as a DocsKit::ApiClient with a label, lexer and template" do
+      curl = described_class.new.api_clients[:curl]
+
+      expect(curl).to be_a(DocsKit::ApiClient)
+      expect(curl.label).to eq("cURL")
+      expect(curl.lexer).to eq(:curl)
+      expect(curl.template).to respond_to(:call)
+    end
+
+    it "merges site clients over the defaults, appending new ones in declaration order" do
+      cli = DocsKit::ApiClient.new(label: "CLI", lexer: :shell, template: ->(_req) { "acme do" })
+      DocsKit.configure { |c| c.api_clients = { cli: cli } }
+
+      keys = DocsKit.configuration.api_clients.keys
+      expect(keys).to eq(%i[curl javascript ruby python cli])
+      expect(DocsKit.configuration.api_clients[:cli]).to eq(cli)
+    end
+
+    it "lets a site override a default client by reusing its token" do
+      sdk_ruby = DocsKit::ApiClient.new(label: "Ruby", lexer: :ruby, template: ->(_req) { "Acme.new" })
+      DocsKit.configure { |c| c.api_clients = { ruby: sdk_ruby } }
+
+      clients = DocsKit.configuration.api_clients
+      expect(clients.keys).to eq(%i[curl javascript ruby python]) # order preserved, no dup
+      expect(clients[:ruby]).to eq(sdk_ruby)
+    end
+  end
 end
diff --git a/spec/docs_ui/json_response_spec.rb b/spec/docs_ui/json_response_spec.rb
new file mode 100644
index 0000000..777f3f6
--- /dev/null
+++ b/spec/docs_ui/json_response_spec.rb
@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+RSpec.describe DocsUI::JsonResponse do
+  def render_json(...)
+    described_class.new(...).call
+  end
+
+  it "renders a Hash as pretty-printed JSON with string keys" do
+    html = render_json({ id: "obj_1", nested: { count: 2 } })
+
+    # Rouge highlights the JSON; the string content still appears in the markup.
+    expect(html).to include("id")
+    expect(html).to include("obj_1")
+    expect(html).to include("nested")
+    expect(html).to include("count")
+    expect(html).to include("code-highlight") # went through DocsUI::Code
+  end
+
+  it "deep-stringifies nested symbol keys (no Ruby :symbol syntax leaks in)" do
+    html = render_json({ outer: { inner: :value } })
+
+    expect(html).not_to include(":inner")
+    expect(html).not_to include("=>")
+  end
+
+  it "passes a pre-formatted String body through unchanged" do
+    preformatted = %({\n  "already": "formatted"\n})
+    html = render_json(preformatted)
+
+    expect(html).to include("already")
+    expect(html).to include("formatted")
+  end
+
+  it "renders a filename title bar (default response.json)" do
+    expect(render_json({ a: 1 })).to include("response.json")
+  end
+
+  it "accepts a custom filename" do
+    expect(render_json({ a: 1 }, filename: "webhook.json")).to include("webhook.json")
+  end
+
+  it "escapes HTML in string values (Rouge/Phlex path, no raw injection)" do
+    html = render_json({ note: "<script>alert(1)</script>" })
+
+    expect(html).not_to include("<script>alert(1)</script>")
+    expect(html).to include("&lt;script&gt;")
+  end
+end
diff --git a/spec/docs_ui/request_example_spec.rb b/spec/docs_ui/request_example_spec.rb
new file mode 100644
index 0000000..640653e
--- /dev/null
+++ b/spec/docs_ui/request_example_spec.rb
@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe DocsUI::RequestExample do
+  def render_request(...)
+    described_class.new(...).call
+  end
+
+  it "renders one tab per configured client (the four defaults)" do
+    html = render_request(method: :post, path: "/v1/things", body: { name: "Acme" })
+
+    %w[curl javascript ruby python].each do |token|
+      expect(html.scan(%(data-testid="code-lang-#{token}")).size).to eq(1)
+    end
+    expect(html.scan('data-docs-nav-target="codePanel"').size).to eq(4)
+  end
+
+  it "labels each tab from the configured language labels" do
+    html = render_request(method: :get, path: "/v1/things")
+
+    expect(html).to include(">cURL<")
+    expect(html).to include(">JavaScript<")
+    expect(html).to include(">Ruby<")
+    expect(html).to include(">Python<")
+  end
+
+  it "builds the curl tab from api_base_url + path, method and a -d JSON body" do
+    DocsKit.configure { |c| c.api_base_url = "https://api.acme.test" }
+    html = render_request(method: :post, path: "/v1/things", body: { name: "Acme" })
+
+    expect(html).to include("https://api.acme.test/v1/things")
+    expect(html).to include("curl -X POST")
+    expect(html).to include("Acme") # the JSON body payload
+  end
+
+  it "injects the configured auth header into the curl snippet" do
+    DocsKit.configure { |c| c.api_auth_header = "Authorization: Bearer sk_live_..." }
+    html = render_request(method: :get, path: "/v1/things")
+
+    expect(html).to include("Authorization: Bearer sk_live_...")
+  end
+
+  it "filters and orders the tabs when clients: is given" do
+    html = render_request(method: :get, path: "/v1/things", clients: %i[ruby curl])
+
+    expect(html.scan('data-docs-nav-target="codePanel"').size).to eq(2)
+    expect(html).to include('data-testid="code-lang-ruby"')
+    expect(html).to include('data-testid="code-lang-curl"')
+    expect(html).not_to include('data-testid="code-lang-python"')
+    # order follows the clients: array (ruby tab before curl tab)
+    expect(html.index("code-lang-ruby")).to be < html.index("code-lang-curl")
+  end
+
+  it "renders a site-added custom client from config" do
+    cli = DocsKit::ApiClient.new(
+      label: "CLI", lexer: :shell, filename: "acme",
+      template: ->(req) { "acme things create --name #{req.body&.dig(:name)}" }
+    )
+    DocsKit.configure { |c| c.api_clients = { cli: cli } }
+
+    # Alongside curl so Example renders tabs (a lone snippet degrades to no tabs).
+    html = render_request(method: :post, path: "/v1/things", body: { name: "Acme" }, clients: %i[cli curl])
+
+    expect(html).to include(">CLI<") # the client's own label, not the token capitalized
+    expect(html).to include('data-testid="code-lang-cli"')
+    # The snippet ran through the client template (Rouge highlights the :shell
+    # tokens, so assert on the surviving pieces, not the whole command line).
+    expect(html).to include("acme things create")
+    expect(html).to include("Acme")
+  end
+
+  it "omits payload lines in every default template for a body-less GET" do
+    html = render_request(method: :get, path: "/v1/things")
+
+    expect(html).not_to include("-d ") # curl
+    expect(html).not_to include("body: JSON.stringify") # javascript
+    expect(html).not_to include("request.body =")    # ruby
+    expect(html).not_to include("json=")             # python
+  end
+
+  it "keeps Example's progressive-enhancement markup (no server-side hidden panels)" do
+    html = render_request(method: :get, path: "/v1/things")
+
+    # Example never sets the `hidden` attribute server-side; the docs-nav JS
+    # toggles it. With JS off every panel is visible (all four still present).
+    expect(html).to include('data-docs-nav-target="codeGroup"')
+    expect(html.scan('data-docs-nav-target="codePanel"').size).to eq(4)
+    expect(html).not_to match(/<[^>]*\shidden(\s|>|=)/) # no `hidden` HTML attribute
+  end
+end