Use this annotation on a service method param when you want to directly control the request body of a POST/PUT request (instead of sending in as request parameters or form-style request body). The object will be serialized using the Retrofit instance Converter and the result will be set directly as the request body.

An invocation of a Retrofit method that sends a request to a webserver and returns a response. Each call yields its own HTTP request and response pair. Use #clone to make multiple calls with the same parameters to the same webserver; this may be used to implement polling or to retry a failed call.

Adapts a Call with response type R into the type of T. Instances are created by a factory which is into the Retrofit instance.

Communicates responses from a server or offline requests. One and only one method will be invoked in response to a given request.

Convert objects to and from their representation in HTTP. Instances are created by which is installed into the Retrofit instance.

Make a DELETE request.

Extends ParametersAreNonnullByDefault to also apply to Method results and fields.

Named pair for a form-encoded request.

Named key/value pairs for a form-encoded request.

Denotes that the request body will use form URL encoding. Fields should be declared as parameters and annotated with @Field.

Make a GET request.

Make a HEAD request.

Replaces the header with the value of its target.

  @GET("/")
  Call<ResponseBody> foo(@Header("Accept-Language") String lang);
  

Adds headers specified in the Map or okhttp3.Headers.

Adds headers literally supplied in the value.

  @Headers("Cache-Control: max-age=640000")
  @GET("/")
  ...
 
  @Headers({
    "X-Foo: Bar",
    "X-Ping: Pong"
  })
  @GET("/")
  ...
  

Use a custom HTTP verb for a request.

  interface Service {
    @HTTP(method = "CUSTOM", path = "custom/endpoint/")
    Call<ResponseBody> customEndpoint();
  }
  

  interface Service {
    @HTTP(method = "DELETE", path = "remove/", hasBody = true)
    Call<ResponseBody> deleteObject(@Body RequestBody object);
  }
  

Exception for an unexpected, non-2xx HTTP response.

A single invocation of a Retrofit service interface method. This class captures both the method that was called and the arguments to the method.

Denotes that the request body is multi-part. Parts should be declared as parameters and annotated with @Part.

Make an OPTIONS request.

Denotes a single part of a multi-part request.

Denotes name and value parts of a multi-part request.

Make a PATCH request.

Named replacement in a URL path segment. Values are converted to strings using (or Object#toString(), if no matching string converter is installed) and then URL encoded.

Make a POST request.

Make a PUT request.

Query parameter appended to the URL.

Query parameter keys and values appended to the URL.

Query parameter appended to the URL that has no value.

An HTTP response.

Retrofit adapts a Java interface to HTTP calls by using annotations on the declared methods to define how requests are made. Create instances using the builder and pass your interface to #create to generate an implementation.

Change the behavior of a Call<BodyType> return type to not use the for invoking the onResponse or onFailure methods.

  @SkipCallbackExecutor
  @GET("user/{id}/token")
  Call<String> getToken(@Path("id") long id);
  

Treat the response body on methods returning ResponseBody as is, i.e. without converting the body to byte[].

Adds the argument instance as a request tag using the type as the key.

  @GET("/")
  Call<ResponseBody> foo(@Tag String tag);
  

URL resolved against the base URL.

  @GET
  Call<ResponseBody> list(@Url String url);