<p>MockServer supports mocking gRPC services by transparently converting gRPC requests (protobuf over HTTP/2) into JSON-over-HTTP requests internally. This allows the standard expectation matching engine to handle gRPC requests using the same JSON format used for HTTP mocking.</p>

<a id="how_grpc_mocking_works" class="anchor" href="#how_grpc_mocking_works">&nbsp;</a>

<h2>How gRPC Mocking Works</h2>

<p>When MockServer receives a gRPC request:</p>

<ol>
    <li>The protobuf binary body is decoded to JSON using the loaded proto descriptors</li>
    <li>MockServer adds metadata headers to the converted request:
        <ul>
            <li><span class="inline_code">x-grpc-service</span> — the fully-qualified gRPC service name</li>
            <li><span class="inline_code">x-grpc-method</span> — the RPC method name</li>
            <li><span class="inline_code">x-grpc-original-content-type</span> — the original gRPC content type</li>
        </ul>
    </li>
    <li>The converted JSON request is matched against active expectations</li>
    <li>The JSON response is encoded back to protobuf binary and returned as a gRPC response</li>
</ol>

<p>This means you can set up gRPC expectations using the same JSON format and client APIs as HTTP mocking — no special gRPC client tooling is needed.</p>

<a id="loading_proto_descriptors" class="anchor" href="#loading_proto_descriptors">&nbsp;</a>

<h2>Loading Proto Descriptors</h2>

<p>MockServer needs proto descriptors to convert between protobuf binary and JSON. There are three ways to load them:</p>

<h3>1. Pre-compiled Descriptor Files</h3>

<p>Compile your <span class="inline_code">.proto</span> files to descriptor sets and point MockServer at the directory:</p>

<pre class="prettyprint code"><code class="code">protoc --descriptor_set_out=service.dsc --include_imports service.proto</code></pre>

<p>Then configure MockServer:</p>

<pre class="code" style="padding: 2px;"><code class="code">-Dmockserver.grpcDescriptorDirectory="/path/to/descriptors"</code></pre>

<p>Or via environment variable:</p>

<pre class="code" style="padding: 2px;"><code class="code">MOCKSERVER_GRPC_DESCRIPTOR_DIRECTORY=/path/to/descriptors</code></pre>

<h3>2. Proto Source Files (Auto-compiled)</h3>

<p>Point MockServer at a directory of <span class="inline_code">.proto</span> source files and they will be compiled at startup using <span class="inline_code">protoc</span>:</p>

<pre class="code" style="padding: 2px;"><code class="code">-Dmockserver.grpcProtoDirectory="/path/to/protos"</code></pre>

<p>This requires <span class="inline_code">protoc</span> to be available on the system PATH. If <span class="inline_code">protoc</span> is installed elsewhere, configure its path:</p>

<pre class="code" style="padding: 2px;"><code class="code">-Dmockserver.grpcProtocPath="/usr/local/bin/protoc"</code></pre>

<h3>3. REST API Upload</h3>

<p>Upload compiled descriptors at runtime via the REST API:</p>

<pre class="prettyprint code"><code class="code">curl -v -X PUT "http://localhost:1080/mockserver/grpc/descriptors" \
  --data-binary @service.dsc</code></pre>

<a id="grpc_docker" class="anchor" href="#grpc_docker">&nbsp;</a>

<h3>Docker</h3>

<p>When running MockServer in Docker, mount your proto files or descriptors into the container:</p>

<pre class="prettyprint code"><code class="code">docker run -d --rm \
  -p 1080:1080 \
  -v /local/path/to/protos:/protos \
  -e MOCKSERVER_GRPC_PROTO_DIRECTORY=/protos \
  mockserver/mockserver:latest</code></pre>

<p>Replace <span class="inline_code">latest</span> with a specific version tag (e.g. <span class="inline_code">mockserver/mockserver:6.1.0</span>) to pin a known working version.</p>

<a id="creating_grpc_expectations" class="anchor" href="#creating_grpc_expectations">&nbsp;</a>

<h2>Creating gRPC Expectations</h2>

<p>Given a proto file such as:</p>

<pre class="prettyprint code"><code class="code">syntax = "proto3";
package com.example.grpc;

service GreetingService {
  rpc Greeting (HelloRequest) returns (HelloResponse);
  rpc ListGreetings (HelloRequest) returns (stream HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string greeting = 1;
}</code></pre>

<p>You can create expectations that match on the JSON-converted request body and the gRPC metadata headers:</p>

<a id="unary_rpc" class="anchor" href="#unary_rpc">&nbsp;</a>

<h3>Unary RPC</h3>

<button id="button_grpc_unary" class="accordion title"><strong>Unary RPC Code Examples</strong></button>
<div class="panel title">
    <button class="accordion inner">REST API</button>
    <div class="panel">
    <pre class="prettyprint code"><code class="code">curl -v -X PUT "http://localhost:1080/mockserver/expectation" -d '{
  "httpRequest": {
    "method": "POST",
    "path": "/com.example.grpc.GreetingService/Greeting",
    "headers": {
      "x-grpc-service": ["com.example.grpc.GreetingService"],
      "x-grpc-method": ["Greeting"]
    },
    "body": {
      "type": "JSON",
      "json": "{\"name\": \"World\"}"
    }
  },
  "httpResponse": {
    "statusCode": 200,
    "headers": {
      "grpc-status": ["0"]
    },
    "body": "{\"greeting\": \"Hello World\"}"
  }
}'</code></pre>
    </div>
    <button class="accordion inner">Java</button>
    <div class="panel">
    <pre class="prettyprint lang-java code"><code class="code">new MockServerClient("localhost", 1080)
    .when(
        request()
            .withMethod("POST")
            .withPath("/com.example.grpc.GreetingService/Greeting")
            .withHeader("x-grpc-service", "com.example.grpc.GreetingService")
            .withHeader("x-grpc-method", "Greeting")
            .withBody(json("{\"name\": \"World\"}"))
    )
    .respond(
        response()
            .withStatusCode(200)
            .withHeader("grpc-status", "0")
            .withBody("{\"greeting\": \"Hello World\"}")
    );</code></pre>
    </div>
    <button class="accordion inner">Python</button>
    <div class="panel">
    <pre class="prettyprint lang-python code"><code class="code">from mockserver import MockServerClient, HttpRequest, HttpResponse, KeyToMultiValue

client = MockServerClient("localhost", 1080)
client.when(
    HttpRequest(
        method="POST",
        path="/com.example.grpc.GreetingService/Greeting",
        headers=[
            KeyToMultiValue(name="x-grpc-service", values=["com.example.grpc.GreetingService"]),
            KeyToMultiValue(name="x-grpc-method", values=["Greeting"])
        ],
        body={"type": "JSON", "json": '{"name": "World"}'}
    )
).respond(
    HttpResponse(
        status_code=200,
        headers=[KeyToMultiValue(name="grpc-status", values=["0"])],
        body='{"greeting": "Hello World"}'
    )
)</code></pre>
    </div>
    <button class="accordion inner">Ruby</button>
    <div class="panel">
    <pre class="prettyprint lang-ruby code"><code class="code">require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080)
client.when(
  HttpRequest.new(
    method: 'POST',
    path: '/com.example.grpc.GreetingService/Greeting',
    headers: [
      { name: 'x-grpc-service', values: ['com.example.grpc.GreetingService'] },
      { name: 'x-grpc-method', values: ['Greeting'] }
    ],
    body: { type: 'JSON', json: '{"name": "World"}' }
  )
).respond(
  HttpResponse.new(
    status_code: 200,
    headers: [{ name: 'grpc-status', values: ['0'] }],
    body: '{"greeting": "Hello World"}'
  )
)</code></pre>
    </div>
</div>

<a id="server_streaming_rpc" class="anchor" href="#server_streaming_rpc">&nbsp;</a>

<h3>Server Streaming RPC</h3>

<p>For server streaming RPCs, use a gRPC stream response to return multiple messages. Each message can have an optional delay:</p>

<button id="button_grpc_stream" class="accordion title"><strong>Server Streaming RPC Code Examples</strong></button>
<div class="panel title">
    <button class="accordion inner">REST API</button>
    <div class="panel">
    <pre class="prettyprint code"><code class="code">curl -v -X PUT "http://localhost:1080/mockserver/expectation" -d '{
  "httpRequest": {
    "method": "POST",
    "path": "/com.example.grpc.GreetingService/ListGreetings",
    "headers": {
      "x-grpc-service": ["com.example.grpc.GreetingService"],
      "x-grpc-method": ["ListGreetings"]
    }
  },
  "grpcStreamResponse": {
    "statusName": "OK",
    "messages": [
      {"json": "{\"greeting\": \"Hello Alice\"}"},
      {"json": "{\"greeting\": \"Hello Bob\"}", "delay": {"timeUnit": "MILLISECONDS", "value": 100}},
      {"json": "{\"greeting\": \"Hello Charlie\"}", "delay": {"timeUnit": "MILLISECONDS", "value": 200}}
    ]
  }
}'</code></pre>
    </div>
    <button class="accordion inner">Java</button>
    <div class="panel">
    <pre class="prettyprint lang-java code"><code class="code">new MockServerClient("localhost", 1080)
    .when(
        request()
            .withMethod("POST")
            .withPath("/com.example.grpc.GreetingService/ListGreetings")
            .withHeader("x-grpc-service", "com.example.grpc.GreetingService")
            .withHeader("x-grpc-method", "ListGreetings")
    )
    .respondWithGrpcStream(
        grpcStreamResponse()
            .withStatusName("OK")
            .withMessage("{\"greeting\": \"Hello Alice\"}")
            .withMessage("{\"greeting\": \"Hello Bob\"}", delay(MILLISECONDS, 100))
            .withMessage("{\"greeting\": \"Hello Charlie\"}", delay(MILLISECONDS, 200))
    );</code></pre>
    </div>
    <button class="accordion inner">Python</button>
    <div class="panel">
    <pre class="prettyprint lang-python code"><code class="code">from mockserver import MockServerClient, HttpRequest, KeyToMultiValue, GrpcStreamResponse, GrpcStreamMessage, Delay

client = MockServerClient("localhost", 1080)
client.when(
    HttpRequest(
        method="POST",
        path="/com.example.grpc.GreetingService/ListGreetings",
        headers=[
            KeyToMultiValue(name="x-grpc-service", values=["com.example.grpc.GreetingService"]),
            KeyToMultiValue(name="x-grpc-method", values=["ListGreetings"])
        ]
    )
).respond_with_grpc_stream(
    GrpcStreamResponse(
        status_name="OK",
        messages=[
            GrpcStreamMessage(json='{"greeting": "Hello Alice"}'),
            GrpcStreamMessage(json='{"greeting": "Hello Bob"}', delay=Delay(time_unit="MILLISECONDS", value=100)),
            GrpcStreamMessage(json='{"greeting": "Hello Charlie"}', delay=Delay(time_unit="MILLISECONDS", value=200))
        ]
    )
)</code></pre>
    </div>
    <button class="accordion inner">Ruby</button>
    <div class="panel">
    <pre class="prettyprint lang-ruby code"><code class="code">require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080)
client.when(
  HttpRequest.new(
    method: 'POST',
    path: '/com.example.grpc.GreetingService/ListGreetings',
    headers: [
      KeyToMultiValue.new(name: 'x-grpc-service', values: ['com.example.grpc.GreetingService']),
      KeyToMultiValue.new(name: 'x-grpc-method', values: ['ListGreetings'])
    ]
  )
).respond_with_grpc_stream(
  GrpcStreamResponse.new(
    status_name: 'OK',
    messages: [
      GrpcStreamMessage.new(json: '{"greeting": "Hello Alice"}'),
      GrpcStreamMessage.new(json: '{"greeting": "Hello Bob"}', delay: Delay.new(time_unit: 'MILLISECONDS', value: 100)),
      GrpcStreamMessage.new(json: '{"greeting": "Hello Charlie"}', delay: Delay.new(time_unit: 'MILLISECONDS', value: 200))
    ]
  )
)</code></pre>
    </div>
</div>

<a id="client_streaming_rpc" class="anchor" href="#client_streaming_rpc">&nbsp;</a>

<h3>Client Streaming RPC</h3>

<p>Client streaming requests are converted with the combined stream messages in the request body. MockServer adds an <span class="inline_code">x-grpc-client-streaming</span> header to indicate this is a client streaming request. Client streaming support is limited — see <a href="#grpc_limitations">Limitations</a> below.</p>

<a id="matching_grpc_requests" class="anchor" href="#matching_grpc_requests">&nbsp;</a>

<h2>Matching gRPC Requests</h2>

<p>Since gRPC requests are converted to JSON, all standard MockServer matchers work:</p>

<ul>
    <li><strong>Path matching</strong> — match on <span class="inline_code">/package.ServiceName/MethodName</span></li>
    <li><strong>Header matching</strong> — match on <span class="inline_code">x-grpc-service</span> and <span class="inline_code">x-grpc-method</span> headers</li>
    <li><strong>JSON body matching</strong> — match on the JSON-converted protobuf body using exact match, JSON Schema, JsonPath, etc.</li>
    <li><strong>Regex</strong> — use regex matchers on any field</li>
</ul>

<a id="grpc_status_codes" class="anchor" href="#grpc_status_codes">&nbsp;</a>

<h2>gRPC Status Codes</h2>

<p>For unary RPCs, set the gRPC status via the <span class="inline_code">grpc-status</span> response header (as shown in the unary example above). For server streaming RPCs, use the <span class="inline_code">statusName</span> field in the <span class="inline_code">grpcStreamResponse</span> action instead. You can also set a <span class="inline_code">grpc-message</span> header (unary) or <span class="inline_code">statusMessage</span> field (streaming) to provide error details. Standard gRPC status codes are supported:</p>

<table>
    <thead>
        <tr>
            <th>Code</th>
            <th>Name</th>
        </tr>
    </thead>
    <tbody>
        <tr><td>0</td><td>OK</td></tr>
        <tr><td>1</td><td>CANCELLED</td></tr>
        <tr><td>2</td><td>UNKNOWN</td></tr>
        <tr><td>3</td><td>INVALID_ARGUMENT</td></tr>
        <tr><td>4</td><td>DEADLINE_EXCEEDED</td></tr>
        <tr><td>5</td><td>NOT_FOUND</td></tr>
        <tr><td>6</td><td>ALREADY_EXISTS</td></tr>
        <tr><td>7</td><td>PERMISSION_DENIED</td></tr>
        <tr><td>8</td><td>RESOURCE_EXHAUSTED</td></tr>
        <tr><td>9</td><td>FAILED_PRECONDITION</td></tr>
        <tr><td>10</td><td>ABORTED</td></tr>
        <tr><td>11</td><td>OUT_OF_RANGE</td></tr>
        <tr><td>12</td><td>UNIMPLEMENTED</td></tr>
        <tr><td>13</td><td>INTERNAL</td></tr>
        <tr><td>14</td><td>UNAVAILABLE</td></tr>
        <tr><td>15</td><td>DATA_LOSS</td></tr>
        <tr><td>16</td><td>UNAUTHENTICATED</td></tr>
    </tbody>
</table>

<a id="grpc_limitations" class="anchor" href="#grpc_limitations">&nbsp;</a>

<h2>Limitations</h2>

<ul>
    <li><strong>Unary RPC</strong> — fully supported</li>
    <li><strong>Server streaming RPC</strong> — fully supported via <span class="inline_code">grpcStreamResponse</span></li>
    <li><strong>Client streaming RPC</strong> — limited support; stream messages are aggregated into a single request body</li>
    <li><strong>Bidirectional streaming RPC</strong> — not yet supported</li>
</ul>

<a id="grpc_fault_injection_link" class="anchor" href="#grpc_fault_injection_link">&nbsp;</a>

<h2>gRPC Fault Injection (Chaos)</h2>

<p>MockServer can inject gRPC-level faults — <code class="inline code">UNAVAILABLE</code>, <code class="inline code">DEADLINE_EXCEEDED</code>, <code class="inline code">RESOURCE_EXHAUSTED</code>, and other status codes — into matched RPC calls, with optional latency and request-quota controls. Faults are registered per gRPC service name via a dedicated control-plane endpoint and apply before normal request conversion in <code class="inline code">GrpcToHttpRequestHandler</code>.</p>

<p>This is separate from the health-check serving-status feature described below. See the <a href="/mock_server/chaos_testing.html#grpc_fault_injection">gRPC Fault Injection</a> section on the Chaos Testing page for the full profile reference and REST API examples.</p>

<a id="grpc_health_check" class="anchor" href="#grpc_health_check">&nbsp;</a>

<h2>gRPC Health Checking Protocol</h2>

<p>Kubernetes readiness and liveness probes commonly use the <a href="https://github.com/grpc/grpc/blob/master/doc/health-checking.md">gRPC Health Checking Protocol</a> (<code class="inline code">grpc.health.v1.Health/Check</code>) to verify that a service is ready to receive traffic. MockServer auto-responds to this well-known method <strong>without requiring a proto descriptor</strong> — protobuf encoding and decoding is handled manually so health checks work out of the box even when no descriptors have been loaded.</p>

<p>Health checks are enabled by default (<code class="inline code">grpcHealthCheckEnabled=true</code>). The default serving status for all services is <code class="inline code">SERVING</code>. You can override the status for individual services or for the global default via a REST endpoint.</p>

<h3>ServingStatus values</h3>

<table class="table-standard">
    <thead>
        <tr>
            <th>Value</th>
            <th>Proto code</th>
            <th>Meaning</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><code class="inline code">SERVING</code></td>
            <td>1</td>
            <td>The service is healthy and ready to accept requests (default)</td>
        </tr>
        <tr>
            <td><code class="inline code">NOT_SERVING</code></td>
            <td>2</td>
            <td>The service is temporarily unavailable (probe will fail)</td>
        </tr>
        <tr>
            <td><code class="inline code">UNKNOWN</code></td>
            <td>0</td>
            <td>Status is unknown</td>
        </tr>
        <tr>
            <td><code class="inline code">SERVICE_UNKNOWN</code></td>
            <td>3</td>
            <td>The named service is not known to this server</td>
        </tr>
    </tbody>
</table>

<h3>REST API</h3>

<p><strong>Override the status for a named service:</strong></p>
<pre class="prettyprint code"><code class="code">curl -v -X PUT "http://localhost:1080/mockserver/grpc/health" \
  -H "Content-Type: application/json" \
  -d '{"service": "my.payments.PaymentService", "status": "NOT_SERVING"}'</code></pre>

<p>Set <code class="inline code">service</code> to the fully-qualified gRPC service name. Use an empty string (<code class="inline code">""</code>) to override the default status that applies to <em>all</em> services without an explicit override. The response confirms the registration:</p>

<pre class="prettyprint code"><code class="code">{ "status": "registered", "service": "my.payments.PaymentService", "servingStatus": "NOT_SERVING" }</code></pre>

<p><strong>Read all current status overrides:</strong></p>
<pre class="prettyprint code"><code class="code">curl -v "http://localhost:1080/mockserver/grpc/health"</code></pre>

<p>Returns a JSON object mapping service names to their current status. The empty string key (<code class="inline code">"_default"</code>) shows the global default:</p>

<pre class="prettyprint code"><code class="code">{
  "_default": "SERVING",
  "my.payments.PaymentService": "NOT_SERVING"
}</code></pre>

<p>All status overrides are cleared on server reset. The <code class="inline code">GET</code> endpoint returns only services that have had their status explicitly set, plus the global default.</p>

<h3>How it works</h3>

<p>When MockServer receives a request whose path is exactly <code class="inline code">/grpc.health.v1.Health/Check</code>, the request is intercepted in <code class="inline code">GrpcToHttpRequestHandler</code> before descriptor lookup — no proto descriptor for the health service is needed. <code class="inline code">GrpcHealthCheckHandler</code> decodes the 5-byte gRPC frame header and then manually parses the protobuf <code class="inline code">HealthCheckRequest</code> (field 1 = service name string). It looks up the serving status in <code class="inline code">GrpcHealthRegistry</code>, which falls back to the default status when no per-service override is registered. The response is a manually-encoded gRPC-framed <code class="inline code">HealthCheckResponse</code> (field 1 = status enum varint). The whole path bypasses the expectation matching engine so health checks always respond, even with no expectations registered.</p>

<a id="grpc_server_reflection" class="anchor" href="#grpc_server_reflection">&nbsp;</a>

<h2>Server Reflection</h2>

<p>MockServer supports the <strong>gRPC Server Reflection Protocol</strong> out of the box. Tools such as <span class="inline_code">grpcurl</span> and <span class="inline_code">grpcui</span> can use reflection to discover services and describe message types without needing a local <span class="inline_code">.proto</span> file.</p>

<p>Both the v1 and v1alpha reflection service paths are supported:</p>
<ul>
    <li><span class="inline_code">/grpc.reflection.v1.ServerReflection/ServerReflectionInfo</span></li>
    <li><span class="inline_code">/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo</span></li>
</ul>

<p>The reflection service answers from the proto descriptors already loaded into MockServer (via <span class="inline_code">grpcDescriptorDirectory</span>, <span class="inline_code">grpcProtoDirectory</span>, or the REST API upload). No additional configuration is required.</p>

<h3>Example: listing services with grpcurl</h3>

<pre class="prettyprint code"><code class="code"># List all services known to MockServer
grpcurl -plaintext localhost:1080 list

# Describe a specific service
grpcurl -plaintext localhost:1080 describe com.example.grpc.GreetingService

# Describe a message type
grpcurl -plaintext localhost:1080 describe com.example.grpc.HelloRequest</code></pre>

<h3>Limitation</h3>

<p>MockServer's gRPC path is buffered-unary: each HTTP/2 request carries exactly one gRPC message. The reflection handler therefore processes a single <span class="inline_code">ServerReflectionRequest</span> per call. This is sufficient for <span class="inline_code">grpcurl list</span>, single symbol lookups, and single file lookups. Fully interactive bidirectional-streaming reflection (a long-lived stream with multiple back-and-forth messages) is not supported by the current pipeline.</p>

<a id="grpc_web_link" class="anchor" href="#grpc_web_link">&nbsp;</a>

<h2>gRPC-Web Support</h2>

<p>MockServer supports <a href="https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-WEB.md">gRPC-Web</a>, the variant of gRPC designed for browser clients and environments that cannot use HTTP/2 trailers. gRPC-Web requests are automatically detected and translated to standard gRPC for matching against existing expectations, so no additional configuration or separate expectations are needed.</p>

<h3>Supported Content Types</h3>

<ul>
    <li><span class="inline_code">application/grpc-web</span> and <span class="inline_code">application/grpc-web+proto</span> &mdash; binary gRPC-Web (same length-prefixed framing as standard gRPC)</li>
    <li><span class="inline_code">application/grpc-web-text</span> and <span class="inline_code">application/grpc-web-text+proto</span> &mdash; base64-encoded gRPC-Web (the entire request/response body is base64-encoded)</li>
</ul>

<h3>How It Works</h3>

<p>When MockServer receives a request with a gRPC-Web content type:</p>

<ol>
    <li>The request body is decoded (base64-decoded for the <span class="inline_code">-text</span> variant) and the content type is translated to <span class="inline_code">application/grpc</span></li>
    <li>The request is processed through the normal gRPC pipeline &mdash; descriptor lookup, protobuf-to-JSON conversion, and expectation matching all work unchanged</li>
    <li>The response is re-framed as gRPC-Web: the message frame(s) are followed by a trailer frame (flag byte <span class="inline_code">0x80</span>) containing <span class="inline_code">grpc-status</span> and <span class="inline_code">grpc-message</span> as ASCII lines in the body, instead of HTTP/2 trailers</li>
    <li>For the <span class="inline_code">-text</span> variant, the entire response body is base64-encoded</li>
</ol>

<p>gRPC-Web works over both HTTP/1.1 and HTTP/2, making it suitable for browser-based gRPC clients such as <a href="https://github.com/nicholasgasior/grpc-web">grpc-web</a> and <a href="https://github.com/nicholasgasior/grpc-web">Improbable grpc-web</a>.</p>

<h3>Built-in Services via gRPC-Web</h3>

<p>The built-in gRPC health check (<span class="inline_code">/grpc.health.v1.Health/Check</span>), server reflection, and chaos fault injection all work transparently via gRPC-Web. No special configuration is needed.</p>

<h3>Connect Protocol (connectrpc)</h3>

<p>The <a href="https://connectrpc.com/docs/protocol/">Connect protocol</a> (used by <span class="inline_code">connectrpc</span>) is not currently supported. Connect uses a different framing format (JSON or proto over standard HTTP POST with <span class="inline_code">application/connect+proto</span> content type and trailers in a JSON envelope) that is distinct from gRPC-Web. If you need Connect support, please open a feature request.</p>

<a id="grpc_configuration_link" class="anchor" href="#grpc_configuration_link">&nbsp;</a>

<h2>Configuration</h2>

<p>For full details on gRPC configuration properties, see the <a href="/mock_server/configuration_properties.html#grpc_configuration">gRPC Configuration</a> section on the Configuration page.</p>
