How to POST raw whole JSON in the body of a Retrofit request?


This question may have been asked before but no it was not definitively answered. How exactly does one post raw whole JSON inside the body of a Retrofit request?

See similar question here. Or is this answer correct that it must be form url encoded and passed as a field? I really hope not, as the services I am connecting to are just expecting raw JSON in the body of the post. They are not set up to look for a particular field for the JSON data.

I just want to clarify this with the restperts once and for all. One person answered not to use Retrofit. The other was not certain of the syntax. Another thinks yes it can be done but only if its form url-encoded and placed in a field (that's not acceptable in my case). No, I can't re-code all the services for my Android client. And yes, it's very common in major projects to post raw JSON instead of passing over JSON content as field property values. Let's get it right and move on. Can someone point to the documentation or example that shows how this is done? Or provide a valid reason why it can/should not be done.

UPDATE: One thing I can say with 100% certainty. You CAN do this in Google's Volley. It's built right in. Can we do this in Retrofit?

This question is tagged with android rest http-post retrofit android-json

~ Asked on 2014-01-28 06:40:16

The Best Answer is


The @Body annotation defines a single request body.

interface Foo {
  FooResponse postJson(@Body FooRequest body);

Since Retrofit uses Gson by default, the FooRequest instances will be serialized as JSON as the sole body of the request.

public class FooRequest {
  final String foo;
  final String bar;

  FooRequest(String foo, String bar) { = foo; = bar;

Calling with:

FooResponse = foo.postJson(new FooRequest("kit", "kat"));

Will yield the following body:


The Gson docs have much more on how object serialization works.

Now, if you really really want to send "raw" JSON as the body yourself (but please use Gson for this!) you still can using TypedInput:

interface Foo {
  FooResponse postRawJson(@Body TypedInput body);

TypedInput is a defined as "Binary data with an associated mime type.". There's two ways to easily send raw data with the above declaration:

  1. Use TypedByteArray to send raw bytes and the JSON mime type:

    String json = "{\"foo\":\"kit\",\"bar\":\"kat\"}";
    TypedInput in = new TypedByteArray("application/json", json.getBytes("UTF-8"));
    FooResponse response = foo.postRawJson(in);
  2. Subclass TypedString to create a TypedJsonString class:

    public class TypedJsonString extends TypedString {
      public TypedJsonString(String body) {
      @Override public String mimeType() {
        return "application/json";

    And then use an instance of that class similar to #1.

~ Answered on 2014-01-29 05:47:36


Instead of classes we can also directly use the HashMap<String, Object> to send body parameters for example

interface Foo {
  FooResponse postJson(@Body HashMap<String, Object> body);

~ Answered on 2015-02-25 06:04:07

Most Viewed Questions: