# Using the legacy REST Client

| This guide is about the REST Client compatible with RESTEasy Classic which used to be the default Jakarta REST (formerly known as JAX-RS) implementation until Quarkus 2.8. It is now recommended to use Quarkus REST (formerly RESTEasy Reactive), which supports equally well traditional blocking workloads and reactive workloads. For more information about Quarkus REST, please see the REST Client guide and, for the server side, the introductory REST JSON guide or the more detailed Quarkus REST guide.

This guide explains how to use the RESTEasy REST Client in order to interact with REST APIs with very little effort.

| there is another guide if you need to write server JSON REST APIs.

## Prerequisites

To complete this guide, you need:

- Roughly 15 minutes

- An IDE

- JDK 17+ installed with `JAVA_HOME` configured appropriately

- Apache Maven 3.9.9

- Optionally the Quarkus CLI if you want to use it

- Optionally Mandrel or GraalVM installed and configured appropriately if you want to build a native executable (or Docker if you use a native container build)

## Solution

We recommend that you follow the instructions in the next sections and create the application step by step. However, you can go right to the completed example.

Clone the Git repository: `git clone https://github.com/quarkusio/quarkus-quickstarts.git`, or download an archive.

The solution is located in the `resteasy-client-quickstart` directory.

## Creating the Maven project

First, we need a new project. Create a new project with the following command:

CLI

    quarkus create app org.acme:resteasy-client-quickstart \
        --extension='resteasy,resteasy-jackson,resteasy-client,resteasy-client-jackson' \
        --no-code
    cd resteasy-client-quickstart

To create a Gradle project, add the `--gradle` or `--gradle-kotlin-dsl` option.

For more information about how to install and use the Quarkus CLI, see the Quarkus CLI guide.

Maven

    mvn io.quarkus.platform:quarkus-maven-plugin:3.26.0.CR1:create \
        -DprojectGroupId=org.acme \
        -DprojectArtifactId=resteasy-client-quickstart \
        -Dextensions='resteasy,resteasy-jackson,resteasy-client,resteasy-client-jackson' \
        -DnoCode
    cd resteasy-client-quickstart

To create a Gradle project, add the `-DbuildTool=gradle` or `-DbuildTool=gradle-kotlin-dsl` option.

For Windows users:

- If using cmd, (don’t use backward slash `\` and put everything on the same line)

- If using Powershell, wrap `-D` parameters in double quotes e.g. `"-DprojectArtifactId=resteasy-client-quickstart"`

This command generates the Maven project with a REST endpoint and imports:

- the `resteasy` and `resteasy-jackson` extensions for the REST server support;

- the `resteasy-client` and `resteasy-client-jackson` extensions for the REST client support.

If you already have your Quarkus project configured, you can add the `resteasy-client` and the `resteasy-client-jackson` extensions to your project by running the following command in your project base directory:

CLI

    quarkus extension add resteasy-client,resteasy-client-jackson

Maven

    ./mvnw quarkus:add-extension -Dextensions='resteasy-client,resteasy-client-jackson'

Gradle

    ./gradlew addExtension --extensions='resteasy-client,resteasy-client-jackson'

This will add the following to your `pom.xml`:

pom.xml

    <dependency>
        <groupId>io.quarkus</groupId>
        <artifactId>quarkus-resteasy-client</artifactId>
    </dependency>
    <dependency>
        <groupId>io.quarkus</groupId>
        <artifactId>quarkus-resteasy-client-jackson</artifactId>
    </dependency>

build.gradle

    implementation("io.quarkus:quarkus-resteasy-client")
    implementation("io.quarkus:quarkus-resteasy-client-jackson")

## Setting up the model

In this guide we will be demonstrating how to consume part of the REST API supplied by the stage.code.quarkus.io service. Our first order of business is to set up the model we will be using, in the form of an `Extension` POJO.

Create a `src/main/java/org/acme/rest/client/Extension.java` file and set the following content:

    package org.acme.rest.client;

    import java.util.List;

    public class Extension {

        public String id;
        public String name;
        public String shortName;
        public List<String> keywords;

    }

The model above is only a subset of the fields provided by the service, but it suffices for the purposes of this guide.

## Create the interface

Using the RESTEasy REST Client is as simple as creating an interface using the proper Jakarta REST and MicroProfile annotations. In our case the interface should be created at `src/main/java/org/acme/rest/client/ExtensionsService.java` and have the following content:

    package org.acme.rest.client;

    import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
    import org.jboss.resteasy.annotations.jaxrs.QueryParam;

    import jakarta.ws.rs.GET;
    import jakarta.ws.rs.Path;
    import jakarta.ws.rs.QueryParam;
    import java.util.Set;

    @Path("/extensions")
    @RegisterRestClient
    public interface ExtensionsService {

        @GET
        Set<Extension> getById(@QueryParam String id);
    }

The `getById` method gives our code the ability to get an extension by id from the Code Quarkus API. The client will handle all the networking and marshalling leaving our code clean of such technical details.

The purpose of the annotations in the code above is the following:

- `@RegisterRestClient` allows Quarkus to know that this interface is meant to be available for CDI injection as a REST Client

- `@Path`, `@GET` and `@QueryParam` are the standard Jakarta REST annotations used to define how to access the service

| When a JSON extension is installed such as `quarkus-resteasy-client-jackson` or `quarkus-resteasy-client-jsonb`, Quarkus will use the `application/json` media type by default for most return values, unless the media type is explicitly set via `@Produces` or `@Consumes` annotations (there are some exceptions for well known types, such as `String` and `File`, which default to `text/plain` and `application/octet-stream` respectively). If you don’t want JSON by default you can set `quarkus.resteasy-json.default-json=false` and the default will change back to being auto-negotiated. If you set this you will need to add `@Produces(MediaType.APPLICATION_JSON)` and `@Consumes(MediaType.APPLICATION_JSON)` to your endpoints in order to use JSON. If you don’t rely on the JSON default, it is heavily recommended to annotate your endpoints with the `@Produces` and `@Consumes` annotations to define precisely the expected content-types. It will allow to narrow down the number of Jakarta REST providers (which can be seen as converters) included in the native executable.

### Path Parameters

If the GET request requires path parameters you can leverage the `@PathParam("parameter-name")` annotation instead of (or in addition to) the `@QueryParam`. Path and query parameters can be combined, as required, as illustrated in a mock example below.

    package org.acme.rest.client;

    import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
    import org.jboss.resteasy.annotations.jaxrs.PathParam;
    import org.jboss.resteasy.annotations.jaxrs.QueryParam;

    import jakarta.ws.rs.GET;
    import jakarta.ws.rs.Path;
    import java.util.Set;

    @Path("/extensions")
    @RegisterRestClient
    public interface ExtensionsService {

        @GET
        @Path("/stream/{stream}")
        Set<Extension> getByStream(@PathParam String stream, @QueryParam("id") String id);
    }

## Create the configuration

In order to determine the base URL to which REST calls will be made, the REST Client uses configuration from `application.properties`. The name of the property needs to follow a certain convention which is best displayed in the following code:

    # Your configuration properties
    quarkus.rest-client."org.acme.rest.client.ExtensionsService".url=https://stage.code.quarkus.io/api # (1)
    quarkus.rest-client."org.acme.rest.client.ExtensionsService".scope=jakarta.inject.Singleton # (2)

1 | Having this configuration means that all requests performed using `ExtensionsService` will use `https://stage.code.quarkus.io` as the base URL. Using the configuration above, calling the `getById` method of `ExtensionsService` with a value of `io.quarkus:quarkus-resteasy-client` would result in an HTTP GET request being made to `https://stage.code.quarkus.io/api/extensions?id=io.quarkus:quarkus-rest-client`.
2 | Having this configuration means that the default scope of `ExtensionsService` will be `@Singleton`. Supported scope values are `@Singleton`, `@Dependent`, `@ApplicationScoped` and `@RequestScoped`. The default scope is `@Dependent`. The default scope can also be defined on the interface.

Note that `org.acme.rest.client.ExtensionsService` must match the fully qualified name of the `ExtensionsService` interface we created in the previous section.

| The standard MicroProfile Rest Client properties notation can also be used to configure the client:
    org.acme.rest.client.ExtensionsService/mp-rest/url=https://stage.code.quarkus.io/api
    org.acme.rest.client.ExtensionsService/mp-rest/scope=jakarta.inject.Singleton
If a property is specified via both the Quarkus notation and the MicroProfile notation, the Quarkus notation takes a precedence.

To facilitate the configuration, you can use the `@RegisterRestClient` `configKey` property that allows to use another configuration root than the fully qualified name of your interface.

    @RegisterRestClient(configKey="extensions-api")
    public interface ExtensionsService {
        [...]
    }

    # Your configuration properties
    quarkus.rest-client.extensions-api.url=https://stage.code.quarkus.io/api
    quarkus.rest-client.extensions-api.scope=jakarta.inject.Singleton

### Disabling Hostname Verification

To disable the SSL hostname verification for a specific REST client, add the following property to your configuration:

    quarkus.rest-client.extensions-api.verify-host=false

| This setting should not be used in production as it will disable the SSL hostname verification.

Moreover, you can configure a REST client to use your custom hostname verify strategy. All you need to do is to provide a class that implements the interface `javax.net.ssl.HostnameVerifier` and add the following property to your configuration:

    quarkus.rest-client.extensions-api.hostname-verifier=<full qualified custom hostname verifier class name>

| Quarkus REST client provides an embedded hostname verifier strategy to disable the hostname verification called `io.quarkus.restclient.NoopHostnameVerifier`.

### Disabling SSL verifications

To disable all SSL verifications, add the following property to your configuration:

    quarkus.tls.trust-all=true

| This setting should not be used in production as it will disable any kind of SSL verification.

## Create the Jakarta REST resource

Create the `src/main/java/org/acme/rest/client/ExtensionsResource.java` file with the following content:

    package org.acme.rest.client;

    import org.eclipse.microprofile.rest.client.inject.RestClient;
    import org.jboss.resteasy.annotations.jaxrs.PathParam;

    import jakarta.inject.Inject;
    import jakarta.ws.rs.GET;
    import jakarta.ws.rs.Path;
    import java.util.Set;

    @Path("/extension")
    public class ExtensionsResource {

        @Inject
        @RestClient
        ExtensionsService extensionsService;

        @GET
        @Path("/id/{id}")
        public Set<Extension> id(@PathParam String id) {
            return extensionsService.getById(id);
        }
    }

Note that in addition to the standard CDI `@Inject` annotation, we also need to use the MicroProfile `@RestClient` annotation to inject `ExtensionsService`.

## Update the test

We also need to update the functional test to reflect the changes made to the endpoint. Edit the `src/test/java/org/acme/rest/client/ExtensionsResourceTest.java` file and change the content of the `testExtensionIdEndpoint` method to:

    package org.acme.rest.client;

    import static io.restassured.RestAssured.given;
    import static org.hamcrest.CoreMatchers.hasItem;
    import static org.hamcrest.CoreMatchers.is;
    import static org.hamcrest.Matchers.greaterThan;

    import org.acme.rest.client.resources.WireMockExtensionsResource;
    import org.junit.jupiter.api.Test;

    import io.quarkus.test.common.QuarkusTestResource;
    import io.quarkus.test.junit.QuarkusTest;

    @QuarkusTest
    @QuarkusTestResource(WireMockExtensionsResource.class)
    public class ExtensionsResourceTest {

        @Test
        public void testExtensionsIdEndpoint() {
            given()
                .when().get("/extension/id/io.quarkus:quarkus-rest-client")
                .then()
                .statusCode(200)
                .body("$.size()", is(1),
                    "[0].id", is("io.quarkus:quarkus-rest-client"),
                    "[0].name", is("REST Client Classic"),
                    "[0].keywords.size()", greaterThan(1),
                    "[0].keywords", hasItem("rest-client"));
        }
    }

The code above uses REST Assured's json-path capabilities.

## Redirection

A HTTP server can redirect a response to another location by sending a response with a status code that starts with "3" and a HTTP header "Location" holding the URL to be redirected to. When the REST Client receives a redirection response from a HTTP server, it won’t automatically perform another request to the new location. However, you can enable the automatic redirection by enabling the "follow-redirects" property:

- `quarkus.rest-client.follow-redirects` to enable redirection for all REST clients.

- `quarkus.rest-client.<client-prefix>.follow-redirects` to enable redirection for a specific REST client.

If this property is true, then REST Client will perform a new request that it receives a redirection response from the HTTP server.

Additionally, we can limit the number of redirections using the property "max-redirects".

One important note is that according to the RFC2616 specs, by default the redirection will only happen for GET or HEAD methods.

## Async Support

The rest client supports asynchronous rest calls. Async support comes in 2 flavors: you can return a `CompletionStage` or a `Uni` (requires the `quarkus-resteasy-client-mutiny` extension). Let’s see it in action by adding a `getByIdAsync` method in our `ExtensionsService` REST interface. The code should look like:

    package org.acme.rest.client;

    import java.util.Set;
    import java.util.concurrent.CompletionStage;

    import jakarta.ws.rs.GET;
    import jakarta.ws.rs.Path;

    import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
    import org.jboss.resteasy.annotations.jaxrs.QueryParam;

    @Path("/extensions")
    @RegisterRestClient
    public interface ExtensionsService {

        @GET
        Set<Extension> getById(@QueryParam String id);

        @GET
        CompletionStage<Set<Extension>> getByIdAsync(@QueryParam String id);

    }

Open the `src/main/java/org/acme/rest/client/ExtensionsResource.java` file and update it with the following content:

    package org.acme.rest.client;

    import java.util.Set;
    import java.util.concurrent.CompletionStage;

    import jakarta.inject.Inject;
    import jakarta.ws.rs.GET;
    import jakarta.ws.rs.Path;

    import org.eclipse.microprofile.rest.client.inject.RestClient;
    import org.jboss.resteasy.annotations.jaxrs.PathParam;

    @Path("/extension")
    public class ExtensionsResource {

        @Inject
        @RestClient
        ExtensionsService extensionsService;

        @GET
        @Path("/id/{id}")
        public Set<Extension> id(@PathParam String id) {
            return extensionsService.getById(id);
        }

        @GET
        @Path("/id-async/{id}")
        public CompletionStage<Set<Extension>> idAsync(@PathParam String id) {
            return extensionsService.getByIdAsync(id);
        }

    }

To test asynchronous methods, add the test method below in `ExtensionsResourceTest`:

    @Test
    public void testExtensionIdAsyncEndpoint() {
        given()
            .when().get("/extension/id-async/io.quarkus:quarkus-rest-client")
            .then()
            .statusCode(200)
            .body("$.size()", is(1),
                "[0].id", is("io.quarkus:quarkus-rest-client"),
                "[0].name", is("REST Client Classic"),
                "[0].keywords.size()", greaterThan(1),
                "[0].keywords", hasItem("rest-client"));
    }

The `Uni` version is very similar:

    package org.acme.rest.client;

    import java.util.Set;
    import java.util.concurrent.CompletionStage;

    import jakarta.ws.rs.GET;
    import jakarta.ws.rs.Path;

    import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
    import org.jboss.resteasy.annotations.jaxrs.QueryParam;

    import io.smallrye.mutiny.Uni;

    @Path("/extensions")
    @RegisterRestClient
    public interface ExtensionsService {

        // ...

        @GET
        Uni<Set<Extension>> getByIdAsUni(@QueryParam String id);
    }

The `ExtensionsResource` becomes:

    package org.acme.rest.client;

    import java.util.Set;
    import java.util.concurrent.CompletionStage;

    import jakarta.inject.Inject;
    import jakarta.ws.rs.GET;
    import jakarta.ws.rs.Path;

    import org.eclipse.microprofile.rest.client.inject.RestClient;
    import org.jboss.resteasy.annotations.jaxrs.PathParam;

    import io.smallrye.mutiny.Uni;

    @Path("/extension")
    public class ExtensionsResource {

        @Inject
        @RestClient
        ExtensionsService extensionsService;

        // ...

        @GET
        @Path("/id-uni/{id}")
        public Uni<Set<Extension>> idMutiny(@PathParam String id) {
            return extensionsService.getByIdAsUni(id);
        }
    }

| Mutiny The previous snippet uses Mutiny reactive types. If you are not familiar with Mutiny, check Mutiny - an intuitive reactive programming library.

When returning a `Uni`, every subscription invokes the remote service. It means you can re-send the request by re-subscribing on the `Uni`, or use a `retry` as follows:

    @Inject @RestClient ExtensionsService extensionsService;

    // ...

    extensionsService.getByIdAsUni(id)
        .onFailure().retry().atMost(10);

If you use a `CompletionStage`, you would need to call the service’s method to retry. This difference comes from the laziness aspect of Mutiny and its subscription protocol. More details about this can be found in the Mutiny documentation.

## Custom headers support

The MicroProfile REST client allows amending request headers by registering a `ClientHeadersFactory` with the `@RegisterClientHeaders` annotation.

Let’s see it in action by adding a `@RegisterClientHeaders` annotation pointing to a `RequestUUIDHeaderFactory` class in our `ExtensionsService` REST interface:

    package org.acme.rest.client;

    import java.util.Set;
    import java.util.concurrent.CompletionStage;

    import jakarta.ws.rs.GET;
    import jakarta.ws.rs.Path;

    import org.eclipse.microprofile.rest.client.annotation.RegisterClientHeaders;
    import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
    import org.jboss.resteasy.annotations.jaxrs.QueryParam;

    import io.smallrye.mutiny.Uni;

    @Path("/extensions")
    @RegisterRestClient
    @RegisterClientHeaders(RequestUUIDHeaderFactory.class)
    public interface ExtensionsService {

        @GET
        Set<Extension> getById(@QueryParam String id);

        @GET
        CompletionStage<Set<Extension>> getByIdAsync(@QueryParam String id);

        @GET
        Uni<Set<Extension>> getByIdAsUni(@QueryParam String id);
    }

And the `RequestUUIDHeaderFactory` would look like:

    package org.acme.rest.client;

    import org.eclipse.microprofile.rest.client.ext.ClientHeadersFactory;

    import jakarta.enterprise.context.ApplicationScoped;
    import jakarta.ws.rs.core.MultivaluedHashMap;
    import jakarta.ws.rs.core.MultivaluedMap;
    import java.util.UUID;

    @ApplicationScoped
    public class RequestUUIDHeaderFactory implements ClientHeadersFactory {

        @Override
        public MultivaluedMap<String, String> update(MultivaluedMap<String, String> incomingHeaders, MultivaluedMap<String, String> clientOutgoingHeaders) {
            MultivaluedMap<String, String> result = new MultivaluedHashMap<>();
            result.add("X-request-uuid", UUID.randomUUID().toString());
            return result;
        }
    }

As you see in the example above, you can make your `ClientHeadersFactory` implementation a CDI bean by annotating it with a scope-defining annotation, such as `@Singleton`, `@ApplicationScoped`, etc.

### Default header factory

You can also use `@RegisterClientHeaders` annotation without any custom factory specified. In that case the `DefaultClientHeadersFactoryImpl` factory will be used and all headers listed in `org.eclipse.microprofile.rest.client.propagateHeaders` configuration property will be amended. Individual header names are comma-separated.

    @Path("/extensions")
    @RegisterRestClient
    @RegisterClientHeaders
    public interface ExtensionsService {

        @GET
        Set<Extension> getById(@QueryParam String id);

        @GET
        CompletionStage<Set<Extension>> getByIdAsync(@QueryParam String id);

        @GET
        Uni<Set<Extension>> getByIdAsUni(@QueryParam String id);
    }

    org.eclipse.microprofile.rest.client.propagateHeaders=Authorization,Proxy-Authorization

## Package and run the application

Run the application with:

CLI

    quarkus dev

Maven

    ./mvnw quarkus:dev

Gradle

    ./gradlew --console=plain quarkusDev

Open your browser to http://localhost:8080/extension/id/io.quarkus:quarkus-rest-client.

You should see a JSON object containing some basic information about the REST Client extension.

As usual, the application can be packaged using:

CLI

    quarkus build

Maven

    ./mvnw install

Gradle

    ./gradlew build

And executed with `java -jar target/quarkus-app/quarkus-run.jar`.

You can also generate the native executable with:

CLI

    quarkus build --native

Maven

    ./mvnw install -Dnative

Gradle

    ./gradlew build -Dquarkus.native.enabled=true

## REST Client and RESTEasy interactions

In Quarkus, the REST Client extension and the RESTEasy extension share the same infrastructure. One important consequence of this consideration is that they share the same list of providers (in the Jakarta REST meaning of the word).

For instance, if you declare a `WriterInterceptor`, it will by default intercept both the servers calls and the client calls, which might not be the desired behavior.

However, you can change this default behavior and constrain a provider to:

- only consider client calls by adding the `@ConstrainedTo(RuntimeType.CLIENT)` annotation to your provider;

- only consider server calls by adding the `@ConstrainedTo(RuntimeType.SERVER)` annotation to your provider.

## Using a Mock HTTP Server for tests

In some cases you may want to mock the remote endpoint - the HTTP server - instead of mocking the client itself. This may be especially useful for native tests, or for programmatically created clients.

You can easily mock an HTTP Server with Wiremock. The Wiremock section of the Quarkus - Using the REST Client describes how to set it up in detail.

## Further reading

- MicroProfile Rest Client specification

## Configuration Reference

Configuration property fixed at build time - All other configuration properties are overridable at runtime

Configuration property | Type | Default
--- | --- | ---
`quarkus.rest-client.removes-trailing-slash` If true, the extension will automatically remove the trailing slash in the paths if any. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT_REMOVES_TRAILING_SLASH` | boolean | `true`
`quarkus.rest-client.multipart-post-encoder-mode` Mode in which the form data are encoded. Possible values are `HTML5`, `RFC1738` and `RFC3986`. The modes are described in the Netty documentation By default, Rest Client Reactive uses RFC1738. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT_MULTIPART_POST_ENCODER_MODE` | string |
`quarkus.rest-client.proxy-address` A string value in the form of `:` that specifies the HTTP proxy server hostname (or IP address) and port for requests of clients to use. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_PROXY_ADDRESS` | string |
`quarkus.rest-client.proxy-user` Proxy username, equivalent to the http.proxy or https.proxy JVM settings. Can be overwritten by client-specific settings. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT_PROXY_USER` | string |
`quarkus.rest-client.proxy-password` Proxy password, equivalent to the http.proxyPassword or https.proxyPassword JVM settings. Can be overwritten by client-specific settings. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT_PROXY_PASSWORD` | string |
`quarkus.rest-client.non-proxy-hosts` Hosts to access without proxy, similar to the http.nonProxyHosts or https.nonProxyHosts JVM settings. Please note that unlike the JVM settings, this property is empty by default. Can be overwritten by client-specific settings. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT_NON_PROXY_HOSTS` | string |
`quarkus.rest-client.connect-timeout` A timeout in milliseconds that REST clients should wait to connect to the remote endpoint. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_CONNECT_TIMEOUT` | long | `15000`
`quarkus.rest-client.read-timeout` A timeout in milliseconds that REST clients should wait for a response from the remote endpoint. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_READ_TIMEOUT` | long | `30000`
`quarkus.rest-client.disable-contextual-error-messages` If true, the REST clients will not provide additional contextual information (like REST client class and method names) when exception occurs during a client invocation. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT_DISABLE_CONTEXTUAL_ERROR_MESSAGES` | boolean | `false`
`quarkus.rest-client.user-agent` Default configuration for the HTTP user-agent header to use in all REST clients. Can be overwritten by client-specific settings. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT_USER_AGENT` | string |
`quarkus.rest-client.headers."header-name"` The HTTP headers that should be applied to all requests of the rest client. Environment variable: `QUARKUS_REST_CLIENT_HEADERS__HEADER_NAME_` | Map<String,String> |
`quarkus.rest-client.hostname-verifier` The class name of the host name verifier. The class must have a public no-argument constructor. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_HOSTNAME_VERIFIER` | string |
`quarkus.rest-client.connection-ttl` The time in ms for which a connection remains unused in the connection pool before being evicted and closed. A timeout of `0` means there is no timeout. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_CONNECTION_TTL` | int |
`quarkus.rest-client.connection-pool-size` The size of the connection pool for this client. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_CONNECTION_POOL_SIZE` | int | `50`
`quarkus.rest-client.keep-alive-enabled` If set to false disables the keep alive completely. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_KEEP_ALIVE_ENABLED` | boolean | `true`
`quarkus.rest-client.max-redirects` The maximum number of redirection a request can follow. Can be overwritten by client-specific settings. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT_MAX_REDIRECTS` | int |
`quarkus.rest-client.follow-redirects` A boolean value used to determine whether the client should follow HTTP redirect responses. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_FOLLOW_REDIRECTS` | boolean |
`quarkus.rest-client.providers` Fully-qualified provider classnames to include in the client. The equivalent of the `@RegisterProvider` annotation. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_PROVIDERS` | string |
`quarkus.rest-client.scope` The CDI scope to use for injections of REST client instances. Value can be either a fully qualified class name of a CDI scope annotation (such as "jakarta.enterprise.context.ApplicationScoped") or its simple name (such as"ApplicationScoped"). Default scope for the rest-client extension is "Dependent" (which is the spec-compliant behavior). Default scope for the rest-client-reactive extension is "ApplicationScoped". Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_SCOPE` | string |
`quarkus.rest-client.query-param-style` An enumerated type string value with possible values of "MULTI_PAIRS" (default), "COMMA_SEPARATED", or "ARRAY_PAIRS" that specifies the format in which multiple values for the same query parameter is used. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_QUERY_PARAM_STYLE` | `multi-pairs`, `comma-separated`, `array-pairs` |
`quarkus.rest-client.verify-host` Set whether hostname verification is enabled. Default is enabled. This setting should not be disabled in production as it makes the client vulnerable to MITM attacks. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_VERIFY_HOST` | boolean |
`quarkus.rest-client.trust-store` The trust store location. Can point to either a classpath resource or a file. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_TRUST_STORE` | string |
`quarkus.rest-client.trust-store-password` The trust store password. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_TRUST_STORE_PASSWORD` | string |
`quarkus.rest-client.trust-store-type` The type of the trust store. Defaults to "JKS". Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_TRUST_STORE_TYPE` | string |
`quarkus.rest-client.key-store` The key store location. Can point to either a classpath resource or a file. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_KEY_STORE` | string |
`quarkus.rest-client.key-store-password` The key store password. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_KEY_STORE_PASSWORD` | string |
`quarkus.rest-client.key-store-type` The type of the key store. Defaults to "JKS". Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_KEY_STORE_TYPE` | string |
`quarkus.rest-client.tls-configuration-name` The name of the TLS configuration to use. If a name is configured, it uses the configuration from `quarkus.tls.<name>.*` If a name is configured, but no TLS configuration is found with that name then an error will be thrown. The default TLS configuration will be ignored. If no named TLS configuration is set, then the key-store, trust-store, etc. properties will be used. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT_TLS_CONFIGURATION_NAME` | string |
`quarkus.rest-client.http2` If this is true then HTTP/2 will be enabled. Environment variable: `QUARKUS_REST_CLIENT_HTTP2` | boolean | `false`
`quarkus.rest-client.http2-upgrade-max-content-length` Configures the HTTP/2 upgrade maximum length of the aggregated content in bytes. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT_HTTP2_UPGRADE_MAX_CONTENT_LENGTH` | MemorySize | `64K`
`quarkus.rest-client.max-chunk-size` Configures two different things: The max HTTP chunk size, up to `Integer.MAX_VALUE` bytes. The size of the chunk to be read when an `InputStream` is being used as an input Can be overwritten by client-specific settings. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT_MAX_CHUNK_SIZE` | MemorySize | `8k`
`quarkus.rest-client.enable-compression` Supports receiving compressed messages using GZIP. When this feature is enabled and a server returns a response that includes the header `Content-Encoding: gzip`, REST Client will automatically decode the content and proceed with the message handling. This property is not applicable to the RESTEasy Client. Can be overwritten by client-specific settings. Environment variable: `QUARKUS_REST_CLIENT_ENABLE_COMPRESSION` | boolean |
`quarkus.rest-client.alpn` If the Application-Layer Protocol Negotiation is enabled, the client will negotiate which protocol to use over the protocols exposed by the server. By default, it will try to use HTTP/2 first and if it’s not enabled, it will use HTTP/1.1. When the property `http2` is enabled, this flag will be automatically enabled. Environment variable: `QUARKUS_REST_CLIENT_ALPN` | boolean |
`quarkus.rest-client.capture-stacktrace` If `true`, the stacktrace of the invocation of the REST Client method is captured. This stacktrace will be used if the invocation throws an exception Environment variable: `QUARKUS_REST_CLIENT_CAPTURE_STACKTRACE` | boolean | `false`
`quarkus.rest-client.logging.scope` Scope of logging for the client. WARNING: beware of logging sensitive data The possible values are: `request-response` - enables logging request and responses, including redirect responses `all` - enables logging requests and responses and lower-level logging `none` - no additional logging This property is applicable to reactive REST clients only. Environment variable: `QUARKUS_REST_CLIENT_LOGGING_SCOPE` | string |
`quarkus.rest-client.logging.body-limit` How many characters of the body should be logged. Message body can be large and can easily pollute the logs. By default, set to 100. This property is applicable to reactive REST clients only. Environment variable: `QUARKUS_REST_CLIENT_LOGGING_BODY_LIMIT` | int | `100`
`quarkus.rest-client."clients".scope` The CDI scope to use for injection. This property can contain either a fully qualified class name of a CDI scope annotation (such as "jakarta.enterprise.context.ApplicationScoped") or its simple name (such as "ApplicationScoped"). By default, this is not set which means the interface is not registered as a bean unless it is annotated with `RegisterRestClient`. If an interface is not annotated with `RegisterRestClient` and this property is set, then Quarkus will make the interface a bean of the configured scope. Environment variable: `QUARKUS_REST_CLIENT__CLIENTS__SCOPE` | string |
`quarkus.rest-client."clients".enable-local-proxy` If set to true, then Quarkus will ensure that all calls from the REST client go through a local proxy server (that is managed by Quarkus). This can be very useful for capturing network traffic to a service that uses HTTPS. This property is not applicable to the RESTEasy Client, only the Quarkus REST client (formerly RESTEasy Reactive client). This property only applicable to dev and test mode. Environment variable: `QUARKUS_REST_CLIENT__CLIENTS__ENABLE_LOCAL_PROXY` | boolean | `false`
`quarkus.rest-client."clients".local-proxy-provider` This setting is used to select which proxy provider to use if there are multiple ones. It only applies if `enable-local-proxy` is true. The algorithm for picking between multiple provider is the following: If only the default is around, use it (its name is `default`) If there is only one besides the default, use it If there are multiple ones, fail Environment variable: `QUARKUS_REST_CLIENT__CLIENTS__LOCAL_PROXY_PROVIDER` | string |
`quarkus.rest-client."clients".removes-trailing-slash` If true, the extension will automatically remove the trailing slash in the paths if any. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENTS__REMOVES_TRAILING_SLASH` | boolean | `true`
`quarkus.rest-client."client".url` The base URL to use for this service. This property or the `uri` property is considered required, unless the `baseUri` attribute is configured in the `@RegisterRestClient` annotation. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__URL` | string |
`quarkus.rest-client."client".uri` The base URI to use for this service. This property or the `url` property is considered required, unless the `baseUri` attribute is configured in the `@RegisterRestClient` annotation. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__URI` | string |
`quarkus.rest-client."client".override-uri` This property is only meant to be set by advanced configurations to override whatever value was set for the uri or url. The override is done using the REST Client class name configuration syntax. This property is not applicable to the RESTEasy Client, only the Quarkus Rest client (formerly RESTEasy Reactive client). Environment variable: `QUARKUS_REST_CLIENT__CLIENT__OVERRIDE_URI` | string |
`quarkus.rest-client."client".providers` Map where keys are fully-qualified provider classnames to include in the client, and values are their integer priorities. The equivalent of the `@RegisterProvider` annotation. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__PROVIDERS` | string |
`quarkus.rest-client."client".connect-timeout` Timeout specified in milliseconds to wait to connect to the remote endpoint. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__CONNECT_TIMEOUT` | long |
`quarkus.rest-client."client".read-timeout` Timeout specified in milliseconds to wait for a response from the remote endpoint. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__READ_TIMEOUT` | long |
`quarkus.rest-client."client".follow-redirects` A boolean value used to determine whether the client should follow HTTP redirect responses. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__FOLLOW_REDIRECTS` | boolean |
`quarkus.rest-client."client".multipart-post-encoder-mode` Mode in which the form data are encoded. Possible values are `HTML5`, `RFC1738` and `RFC3986`. The modes are described in the Netty documentation By default, Rest Client Reactive uses RFC1738. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__MULTIPART_POST_ENCODER_MODE` | string |
`quarkus.rest-client."client".proxy-address` A string value in the form of `:` that specifies the HTTP proxy server hostname (or IP address) and port for requests of this client to use. Use `none` to disable proxy Environment variable: `QUARKUS_REST_CLIENT__CLIENT__PROXY_ADDRESS` | string |
`quarkus.rest-client."client".proxy-user` Proxy username. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__PROXY_USER` | string |
`quarkus.rest-client."client".proxy-password` Proxy password. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__PROXY_PASSWORD` | string |
`quarkus.rest-client."client".non-proxy-hosts` Hosts to access without proxy This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__NON_PROXY_HOSTS` | string |
`quarkus.rest-client."client".query-param-style` An enumerated type string value with possible values of "MULTI_PAIRS" (default), "COMMA_SEPARATED", or "ARRAY_PAIRS" that specifies the format in which multiple values for the same query parameter is used. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__QUERY_PARAM_STYLE` | `multi-pairs`, `comma-separated`, `array-pairs` |
`quarkus.rest-client."client".verify-host` Set whether hostname verification is enabled. Default is enabled. This setting should not be disabled in production as it makes the client vulnerable to MITM attacks. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__VERIFY_HOST` | boolean |
`quarkus.rest-client."client".trust-store` The trust store location. Can point to either a classpath resource or a file. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__TRUST_STORE` | string |
`quarkus.rest-client."client".trust-store-password` The trust store password. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__TRUST_STORE_PASSWORD` | string |
`quarkus.rest-client."client".trust-store-type` The type of the trust store. Defaults to "JKS". Environment variable: `QUARKUS_REST_CLIENT__CLIENT__TRUST_STORE_TYPE` | string |
`quarkus.rest-client."client".key-store` The key store location. Can point to either a classpath resource or a file. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__KEY_STORE` | string |
`quarkus.rest-client."client".key-store-password` The key store password. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__KEY_STORE_PASSWORD` | string |
`quarkus.rest-client."client".key-store-type` The type of the key store. Defaults to "JKS". Environment variable: `QUARKUS_REST_CLIENT__CLIENT__KEY_STORE_TYPE` | string |
`quarkus.rest-client."client".hostname-verifier` The class name of the host name verifier. The class must have a public no-argument constructor. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__HOSTNAME_VERIFIER` | string |
`quarkus.rest-client."client".tls-configuration-name` The name of the TLS configuration to use. If a name is configured, it uses the configuration from `quarkus.tls.<name>.*` If a name is configured, but no TLS configuration is found with that name then an error will be thrown. The default TLS configuration will be ignored. If no named TLS configuration is set, then the key-store, trust-store, etc. properties will be used. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__TLS_CONFIGURATION_NAME` | string |
`quarkus.rest-client."client".connection-ttl` The time in ms for which a connection remains unused in the connection pool before being evicted and closed. A timeout of `0` means there is no timeout. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__CONNECTION_TTL` | int |
`quarkus.rest-client."client".connection-pool-size` The size of the connection pool for this client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__CONNECTION_POOL_SIZE` | int | `50`
`quarkus.rest-client."client".keep-alive-enabled` If set to false disables the keep alive completely. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__KEEP_ALIVE_ENABLED` | boolean |
`quarkus.rest-client."client".max-redirects` The maximum number of redirection a request can follow. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__MAX_REDIRECTS` | int |
`quarkus.rest-client."client".headers."header-name"` The HTTP headers that should be applied to all requests of the rest client. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__HEADERS__HEADER_NAME_` | Map<String,String> |
`quarkus.rest-client."client".shared` Set to true to share the HTTP client between REST clients. There can be multiple shared clients distinguished by name, when no specific name is set, the name `__vertx.DEFAULT` is used. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__SHARED` | boolean |
`quarkus.rest-client."client".name` Set the HTTP client name, used when the client is shared, otherwise ignored. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__NAME` | string |
`quarkus.rest-client."client".user-agent` Configure the HTTP user-agent header to use. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__USER_AGENT` | string |
`quarkus.rest-client."client".http2` If this is true then HTTP/2 will be enabled. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__HTTP2` | boolean |
`quarkus.rest-client."client".http2-upgrade-max-content-length` Configures the HTTP/2 upgrade maximum length of the aggregated content in bytes. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__HTTP2_UPGRADE_MAX_CONTENT_LENGTH` | MemorySize | `64K`
`quarkus.rest-client."client".max-chunk-size` Configures two different things: The max HTTP chunk size, up to `Integer.MAX_VALUE` bytes. The size of the chunk to be read when an `InputStream` is being read and sent to the server This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__MAX_CHUNK_SIZE` | MemorySize | `8K`
`quarkus.rest-client."client".enable-compression` Supports receiving compressed messages using GZIP. When this feature is enabled and a server returns a response that includes the header `Content-Encoding: gzip`, REST Client will automatically decode the content and proceed with the message handling. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__ENABLE_COMPRESSION` | boolean |
`quarkus.rest-client."client".alpn` If the Application-Layer Protocol Negotiation is enabled, the client will negotiate which protocol to use over the protocols exposed by the server. By default, it will try to use HTTP/2 first and if it’s not enabled, it will use HTTP/1.1. When the property `http2` is enabled, this flag will be automatically enabled. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__ALPN` | boolean |
`quarkus.rest-client."client".capture-stacktrace` If `true`, the stacktrace of the invocation of the REST Client method is captured. This stacktrace will be used if the invocation throws an exception Environment variable: `QUARKUS_REST_CLIENT__CLIENT__CAPTURE_STACKTRACE` | boolean |
`quarkus.rest-client."client".disable-default-mapper` If set to `true`, then this REST Client will not the default exception mapper which always throws an exception if HTTP response code >= 400. This property is not applicable to the RESTEasy Client. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__DISABLE_DEFAULT_MAPPER` | boolean | `${microprofile.rest.client.disable.default.mapper:false}`
`quarkus.rest-client."client".logging.scope` Scope of logging for the client. WARNING: beware of logging sensitive data The possible values are: `request-response` - enables logging request and responses, including redirect responses `all` - enables logging requests and responses and lower-level logging `none` - no additional logging This property is applicable to reactive REST clients only. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__LOGGING_SCOPE` | string |
`quarkus.rest-client."client".logging.body-limit` How many characters of the body should be logged. Message body can be large and can easily pollute the logs. By default, set to 100. This property is applicable to reactive REST clients only. Environment variable: `QUARKUS_REST_CLIENT__CLIENT__LOGGING_BODY_LIMIT` | int | `100`

| About the MemorySize format A size configuration option recognizes strings in this format (shown as a regular expression): `[0-9]+[KkMmGgTtPpEeZzYy]?`. If no suffix is given, assume bytes.