[android] 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 related to android rest http-post retrofit android-json

The 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) {
    this.foo = foo;
    this.bar = 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.

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);

Yes I know it's late, but somebody would probably benefit from this.

Using Retrofit2:

I came across this problem last night migrating from Volley to Retrofit2 (and as OP states, this was built right into Volley with JsonObjectRequest), and although Jake's answer is the correct one for Retrofit1.9, Retrofit2 doesn't have TypedString.

My case required sending a Map<String,Object> that could contain some null values, converted to a JSONObject (that won't fly with @FieldMap, neither does special chars, some get converted), so following @bnorms hint, and as stated by Square:

An object can be specified for use as an HTTP request body with the @Body annotation.

The object will also be converted using a converter specified on the Retrofit instance. If no converter is added, only RequestBody can be used.

So this is an option using RequestBody and ResponseBody:

In your interface use @Body with RequestBody

public interface ServiceApi
    Call<ResponseBody> login(@Path("login") String postfix, @Body RequestBody params);  

In your calling point create a RequestBody, stating it's MediaType, and using JSONObject to convert your Map to the proper format:

Map<String, Object> jsonParams = new ArrayMap<>();
//put something inside the map, could be null
jsonParams.put("code", some_code);

RequestBody body = RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"),(new JSONObject(jsonParams)).toString());
//serviceCaller is the interface initialized with retrofit.create...
Call<ResponseBody> response = serviceCaller.login("loginpostfix", body);
response.enqueue(new Callback<ResponseBody>()
        public void onResponse(Call<ResponseBody> call, retrofit2.Response<ResponseBody> rawResponse)
             //get your response....
              Log.d(TAG, "RetroFit2.0 :RetroGetLogin: " + rawResponse.body().string());
            catch (Exception e)

        public void onFailure(Call<ResponseBody> call, Throwable throwable)
        // other stuff...

Hope this Helps anyone!

An elegant Kotlin version of the above, to allow abstracting the parameters from the JSON convertion in the rest of your application code:

interface ServiceApi {

    fun login(username: String, password: String) =
                "username" to username, "password" to password))

    fun jsonLogin(@Body params: RequestBody): Deferred<LoginResult>

    private fun createJsonRequestBody(vararg params: Pair<String, String>) =
                okhttp3.MediaType.parse("application/json; charset=utf-8"), 


In Retrofit2, When you want to send your parameters in raw you must use Scalars.

first add this in your gradle:

compile 'com.squareup.retrofit2:retrofit:2.3.0'
compile 'com.squareup.retrofit2:converter-gson:2.3.0'
compile 'com.squareup.retrofit2:converter-scalars:2.3.0'

Your Interface

public interface ApiInterface {

    String URL_BASE = "";

    @Headers("Content-Type: application/json")
    Call<User> getUser(@Body String body);



   public class SampleActivity extends AppCompatActivity implements Callback<User> {

    protected void onCreate(@Nullable Bundle savedInstanceState) {

        Retrofit retrofit = new Retrofit.Builder()

        ApiInterface apiInterface = retrofit.create(ApiInterface.class);

        // prepare call in Retrofit 2.0
        try {
            JSONObject paramObject = new JSONObject();
            paramObject.put("email", "[email protected]");
            paramObject.put("pass", "4384984938943");

            Call<User> userCall = apiInterface.getUser(paramObject.toString());
        } catch (JSONException e) {

    public void onResponse(Call<User> call, Response<User> response) {

    public void onFailure(Call<User> call, Throwable t) {

Using JsonObject is the way it is:

  1. Create your interface like this:

    public interface laInterfaz{ 
        void registerPayer(@Body JsonObject bean, Callback<JsonObject> callback);
  2. Make the JsonObject acording to the jsons structure.

    JsonObject obj = new JsonObject();
    JsonObject payerReg = new JsonObject();
  3. Call the service:

    service.registerPayer(obj, callBackRegistraPagador);
    Callback<JsonObject> callBackRegistraPagador = new Callback<JsonObject>(){
        public void success(JsonObject object, Response response){
        public void failure(RetrofitError retrofitError){

And that its! In my personal opinion, its a lot better than making pojos and working with the class mess. This is a lot more cleaner.

I particularly like Jake's suggestion of the TypedString subclass above. You could indeed create a variety of subclasses based on the sorts of POST data you plan to push up, each with its own custom set of consistent tweaks.

You also have the option of adding a header annotation to your JSON POST methods in your Retrofit API…

@Headers( "Content-Type: application/json" )
Response fubar( @Body TypedString sJsonBody ) ;

…but using a subclass is more obviously self-documenting.

Response fubar( @Body TypedJsonString jsonBody ) ;

1)Add dependencies-

 compile 'com.google.code.gson:gson:2.6.2'
compile 'com.squareup.retrofit2:retrofit:2.3.0'
compile 'com.squareup.retrofit2:converter-gson:2.3.0'

2) make Api Handler class

    public class ApiHandler {

  public static final String BASE_URL = "URL";  

    private static Webservices apiService;

    public static Webservices getApiService() {

        if (apiService == null) {

           Gson gson = new GsonBuilder()
            Retrofit retrofit = new Retrofit.Builder().addConverterFactory(GsonConverterFactory.create(gson)).baseUrl(BASE_URL).build();

            apiService = retrofit.create(Webservices.class);
            return apiService;
        } else {
            return apiService;


3)make bean classes from Json schema 2 pojo

-Target language : Java -Source type : JSON -Annotation style : Gson -select Include getters and setters -also you may select Allow additional properties


4)make interface fro api calling

    public interface Webservices {

    Call<ResponseBean> ApiName(@Body JsonObject jsonBody);


if you have a form-data parameters then add below line

@Headers("Content-Type: application/x-www-form-urlencoded")

Other way for form-data parameter check this link

5)make JsonObject for passing in to body as parameter

 private JsonObject ApiJsonMap() {

    JsonObject gsonObject = new JsonObject();
    try {
        JSONObject jsonObj_ = new JSONObject();
        jsonObj_.put("key", "value");
        jsonObj_.put("key", "value");
        jsonObj_.put("key", "value");

        JsonParser jsonParser = new JsonParser();
        gsonObject = (JsonObject) jsonParser.parse(jsonObj_.toString());

        //print parameter
        Log.e("MY gson.JSON:  ", "AS PARAMETER  " + gsonObject);

    } catch (JSONException e) {

    return gsonObject;

6) Call Api Like this

private void ApiCallMethod() {
    try {
        if (CommonUtils.isConnectingToInternet(MyActivity.this)) {
            final ProgressDialog dialog;
            dialog = new ProgressDialog(MyActivity.this);

            Call<ResponseBean> registerCall = ApiHandler.getApiService().ApiName(ApiJsonMap());
            registerCall.enqueue(new retrofit2.Callback<ResponseBean>() {
                public void onResponse(Call<ResponseBean> registerCall, retrofit2.Response<ResponseBean> response) {

                    try {
                        //print respone
                        Log.e(" Full json gson => ", new Gson().toJson(response));
                        JSONObject jsonObj = new JSONObject(new Gson().toJson(response).toString());
                        Log.e(" responce => ", jsonObj.getJSONObject("body").toString());

                        if (response.isSuccessful()) {

                            int success = response.body().getSuccess();
                            if (success == 1) {

                            } else if (success == 0) {

                        } else {


                    } catch (Exception e) {
                        try {
                            Log.e("Tag", "error=" + e.toString());

                        } catch (Resources.NotFoundException e1) {


                public void onFailure(Call<ResponseBean> call, Throwable t) {
                    try {
                        Log.e("Tag", "error" + t.toString());

                    } catch (Resources.NotFoundException e) {


        } else {
            Log.e("Tag", "error= Alert no internet");

    } catch (Resources.NotFoundException e) {

Add ScalarsConverterFactory to retrofit:

in gradle:


your retrofit:

retrofit = new Retrofit.Builder()

change your call interface @Body parameter to String, don't forget to add @Headers("Content-Type: application/json"):

@Headers("Content-Type: application/json")
Call<List<Users>> getUsers(@Body String rawJsonString);

now you can post raw json.

I found that when you use a compound object as @Body params, it could not work well with the Retrofit's GSONConverter (under the assumption you are using that). You have to use JsonObject and not JSONObject when working with that, it adds NameValueParams without being verbose about it - you can only see that if you add another dependency of logging interceptor, and other shenanigans.

So what I found the best approach to tackle this is using RequestBody. You turn your object to RequestBody with a simple api call and launch it. In my case I'm converting a map:

   val map = HashMap<String, Any>()
        map["orderType"] = orderType
        map["optionType"] = optionType
        map["baseAmount"] = baseAmount.toString()
        map["openSpotRate"] = openSpotRate.toString()
        map["premiumAmount"] = premiumAmount.toString()
        map["premiumAmountAbc"] = premiumAmountAbc.toString()
        map["conversionSpotRate"] = (premiumAmountAbc / premiumAmount).toString()
        return RequestBody.create(MediaType.parse("application/json; charset=utf-8"), JSONObject(map).toString())

and this is the call:

fun openUsvDeal(
        @Body params: RequestBody,
        @Query("timestamp") timeStamp: Long,
        @Query("appid") appid: String = Constants.APP_ID,
): Call<JsonObject>

You can use hashmap if you don't want to create pojo class for every API call.

HashMap<String,String> hashMap=new HashMap<>();
        hashMap.put("email","[email protected]");

And then send like this

Call<JsonElement> register(@Body HashMap registerApiPayload);

This is what works me for the current version of retrofit 2.6.2,

First of all, we need to add a Scalars Converter to the list of our Gradle dependencies, which would take care of converting java.lang.String objects to text/plain request bodies,


Then, we need to pass a converter factory to our Retrofit builder. It will later tell Retrofit how to convert the @Body parameter passed to the service.

private val retrofitBuilder: Retrofit.Builder by lazy {

Note: In my retrofit builder i have two converters Gson and Scalars you can use both of them but to send Json body we need to focus Scalars so if you don't need Gson remove it

Then Retrofit service with a String body parameter.

@Headers("Content-Type: application/json")
fun saveUser(@Body   user: String): Response<MyResponse>

Then create the JSON body

val user = JsonObject()
 user.addProperty("id", 001)
 user.addProperty("name", "Name")

Call your service


use following to send json

final JSONObject jsonBody = new JSONObject();
    try {

        jsonBody.put("key", "value");

    } catch (JSONException e){
    RequestBody body = RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"),(jsonBody).toString());

and pass it to url

@Body RequestBody key

If you don't want to create extra classes or use JSONObject you can use a HashMap.

Retrofit interface:

fun signUp(@Body params: HashMap<String, String>): Call<ResponseBody>


val map = hashMapOf(
    "username" to username,
    "password" to password,
    "firstName" to firstName,
    "surname" to lastName


Things required to send raw json in Retrofit.

1) Make sure to add the following header and remove any other duplicate header. Since, on Retrofit's official documentation they specifically mention-

Note that headers do not overwrite each other. All headers with the same name will be included in the request.

@Headers({"Content-Type: application/json"})

2) a. If you are using a converter factory you can pass your json as a String, JSONObject, JsonObject and even a POJO. Also have checked, having ScalarConverterFactory is not necessary only GsonConverterFactory does the job.

Call<Response> myApi(@Header("Authorization") String auth, @Header("KEY") String key, 
                     @Body JsonObject/POJO/String requestBody);

2) b. If you are NOT using any converter factory then you MUST use okhttp3's RequestBody as Retrofit's documentation says-

The object will also be converted using a converter specified on the Retrofit instance. If no converter is added, only RequestBody can be used.

RequestBody requestBody=RequestBody.create(MediaType.parse("application/json; charset=utf-8"),jsonString);

Call<Response> myApi(@Header("Authorization") String auth, @Header("KEY") String key, 
                 @Body RequestBody requestBody);

3) Success!!

Based on the top answer, I have a solution to not have to make POJOs for every request.

Example, I want to post this JSON.

    "data" : {
        "mobile" : "qwer",
        "password" : "qwer"
    "commom" : {}

then, I create a common class like this:

import java.util.Map;
import java.util.HashMap;

public class WRequest {

    Map<String, Object> data;
    Map<String, Object> common;

    public WRequest() {
        data = new HashMap<>();
        common = new HashMap<>();

Finally, when I need a json

WRequest request = new WRequest();
request.data.put("type", type);
request.data.put("page", page);

The request marked annotation @Body then can pass to Retrofit.

After so much effort, found that the basic difference is you need to send the JsonObject instead of JSONObject as parameter.

I wanted to compare speed of volley and retrofit for sending and receiving data I wrote below code (for retrofit part)

first dependency:

dependencies {
     implementation 'com.squareup.retrofit2:retrofit:2.4.0'
     implementation 'com.squareup.retrofit2:converter-gson:2.4.0'

Then interface:

 public interface IHttpRequest {

    String BaseUrl="https://example.com/api/";

    Call<JsonElement> register(@Body HashMap registerApiPayload);

and a function to set parameters to post data to server(In MainActivity):

private void Retrofit(){

    Retrofit retrofitRequest = new Retrofit.Builder()

    // set data to send
    HashMap<String,String> SendData =new HashMap<>();

    final IHttpRequest request=retrofitRequest.create(IHttpRequest.class);

    request.register(SendData).enqueue(new Callback<JsonElement>() {
        public void onResponse(Call<JsonElement> call, Response<JsonElement> response) {
            if (response.isSuccessful()){

        public void onFailure(Call<JsonElement> call, Throwable t) {



And I found Retrofit faster than volley in my case.

While creating OkHttpClient that will be used for Retrofit.

add an Interceptor like this.

 private val httpClient = OkHttpClient.Builder()
        .addInterceptor (other interceptors)

        //This Interceptor is the main logging Interceptor
        .addInterceptor { chain ->
            val request = chain.request()
            val jsonObj = JSONObject(Gson().toJson(request))

            val requestBody = (jsonObj
            ?.getJSONObject("class retrofit2.Invocation")
            ?.getJSONArray("arguments")?.get(0) ?: "").toString()
            val url = jsonObj?.getJSONObject("url")?.getString("url") ?: ""
            Timber.d("gsonrequest request url: $url")
            Timber.d("gsonrequest body :$requestBody")

        // Add other configurations

Now your every Retrofit call's URL and request body will be logged in Logcat. Filter it by "gsonrequest"

I tried this: When you are creating your Retrofit instance, add this converter factory to the retrofit builder:

gsonBuilder = new GsonBuilder().serializeNulls()     
your_retrofit_instance = Retrofit.Builder().addConverterFactory( GsonConverterFactory.create( gsonBuilder.create() ) )

API Call

@Headers("Content-Type: application/json")
Call<CommonResponse> setPreferences(@Body RequestData request);

Note: Use GSON library of Retrofit

import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;

public class RequestData {

    private String accessToken;

    private Data data;
    // The above 'Data' is another similar class to add inner JSON objects. JSONObject within a JSONObject.

    public void setAccessToken(String accessToken) {
        this.accessToken = accessToken;

    public void setData(Data data) {
        this.data = data;

I guess that will help, rest all integration you might already have had and we don't need anything fancy to use above code snippet. It's working perfectly for me.

you need to set @Body in interface

@Headers({ "Content-Type: application/json;charset=UTF-8"})
    Call<ApiResponse> loginWithPhone(@Body HashMap<String, String> fields);

To pass the raw body to retrofit just use:

 HashMap<String,String> SendData =new HashMap<>();

        Call<ApiResponse>call = serviceInterface.loginWithPhone(SendData);

this works for me:

Solved my problem based on TommySM answer (see previous). But I didn't need to make login, I used Retrofit2 for testing https GraphQL API like this:

  1. Defined my BaseResponse class with the help of json annotations (import jackson.annotation.JsonProperty).

    public class MyRequest {
        private String query;
        private String operationName;
        private String variables;
        public void setQuery(String query) {
            this.query = query;
        public void setOperationName(String operationName) {
            this.operationName = operationName;
        public void setVariables(String variables) {
            this.variables = variables;
  2. Defined the call procedure in the interface:

    Call<BaseResponse> apicall(@Body RequestBody params);
  3. Called apicall in the body of test: Create a variable of MyRequest type (for example "myLittleRequest").

    Map<String, Object> jsonParams = convertObjectToMap(myLittleRequest);
    RequestBody body = 
         RequestBody.create(okhttp3.MediaType.parse("application/json; charset=utf-8"),
                        (new JSONObject(jsonParams)).toString());
    response = hereIsYourInterfaceName().apicall(body).execute();

For more clarity on the answers given here, this is how you can use the extension functions. This is only if you are using Kotlin

If you are using com.squareup.okhttp3:okhttp:4.0.1 the older methods of creating objects of MediaType and RequestBody have been deprecated and cannot be used in Kotlin.

If you want to use the extension functions to get a MediaType object and a ResponseBody object from your strings, firstly add the following lines to the class in which you expect to use them.

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody

You can now directly get an object of MediaType this way

val mediaType = "application/json; charset=utf-8".toMediaType()

To get an object of RequestBody first convert the JSONObject you want to send to a string this way. You have to pass the mediaType object to it.

val requestBody = myJSONObject.toString().toRequestBody(mediaType)

JSONObject showing error please use

JsonObject paramObject = new JsonObject(); paramObject.addProperty("loginId", vMobile_Email);

enter image description here

Add ScalarsConverterFactory.create() method and pass hard code

Questions with android tag:

Under what circumstances can I call findViewById with an Options Menu / Action Bar item? How to implement a simple scenario the OO way My eclipse won't open, i download the bundle pack it keeps saying error log getting " (1) no such column: _id10 " error java doesn't run if structure inside of onclick listener Cannot retrieve string(s) from preferences (settings) strange error in my Animation Drawable how to put image in a bundle and pass it to another activity FragmentActivity to Fragment A failure occurred while executing com.android.build.gradle.internal.tasks Why am I seeing net::ERR_CLEARTEXT_NOT_PERMITTED errors after upgrading to Cordova Android 8? "Failed to install the following Android SDK packages as some licences have not been accepted" error Android Gradle 5.0 Update:Cause: org.jetbrains.plugins.gradle.tooling.util No Creators, like default construct, exist): cannot deserialize from Object value (no delegate- or property-based Creator WebView showing ERR_CLEARTEXT_NOT_PERMITTED although site is HTTPS WARNING: API 'variant.getJavaCompile()' is obsolete and has been replaced with 'variant.getJavaCompileProvider()' GoogleMaps API KEY for testing Can I use library that used android support with Androidx projects. How to allow all Network connection types HTTP and HTTPS in Android (9) Pie? Android Material and appcompat Manifest merger failed Deprecated Gradle features were used in this build, making it incompatible with Gradle 5.0 How to format DateTime in Flutter , How to get current time in flutter? How to change package name in flutter? Failed to resolve: com.android.support:appcompat-v7:28.0 What is AndroidX? Unable to resolve dependency for ':app@debug/compileClasspath': Could not resolve FirebaseInstanceIdService is deprecated installation app blocked by play protect Handling back button in Android Navigation Component Android design support library for API 28 (P) not working Failed to resolve: com.google.firebase:firebase-core:16.0.1 com.google.android.gms:play-services-measurement-base is being requested by various other libraries java.lang.NoClassDefFoundError:failed resolution of :Lorg/apache/http/ProtocolVersion Install Android App Bundle on device Conflict with dependency 'com.android.support:support-annotations' in project ':app'. Resolved versions for app (26.1.0) and test app (27.1.1) differ. How to develop Android app completely using python? Invoke-customs are only supported starting with android 0 --min-api 26 Flutter.io Android License Status Unknown How to open Android Device Monitor in latest Android Studio 3.1 Default interface methods are only supported starting with Android N How can I change the app display name build with Flutter? Error:(9, 5) error: resource android:attr/dialogCornerRadius not found error: resource android:attr/fontVariationSettings not found Flutter does not find android sdk Error - Android resource linking failed (AAPT2 27.0.3 Daemon #0) Error : Program type already present: android.support.design.widget.CoordinatorLayout$Behavior flutter run: No connected devices Cannot inline bytecode built with JVM target 1.8 into bytecode that is being built with JVM target 1.6 Still getting warning : Configuration 'compile' is obsolete and has been replaced with 'implementation' PANIC: Cannot find AVD system path. Please define ANDROID_SDK_ROOT (in windows 10)

Questions with rest tag:

Access blocked by CORS policy: Response to preflight request doesn't pass access control check Returning data from Axios API Access Control Origin Header error using Axios in React Web throwing error in Chrome JSON parse error: Can not construct instance of java.time.LocalDate: no String-argument constructor/factory method to deserialize from String value How to send json data in POST request using C# How to enable CORS in ASP.net Core WebAPI RestClientException: Could not extract response. no suitable HttpMessageConverter found REST API - Use the "Accept: application/json" HTTP Header 'Field required a bean of type that could not be found.' error spring restful API using mongodb MultipartException: Current request is not a multipart request Sending the bearer token with axios What is the recommended project structure for spring boot rest projects? http post - how to send Authorization header? Send POST data via raw json with postman How to download excel (.xls) file from API in postman? Body of Http.DELETE request in Angular2 How to POST form data with Spring RestTemplate? Spring Resttemplate exception handling Pass multiple parameters to rest API - Spring org.springframework.web.client.HttpClientErrorException: 400 Bad Request How to call a REST web service API from JavaScript? Making a PowerShell POST request if a body param starts with '@' download a file from Spring boot rest service Spring Boot REST API - request timeout? How to pass List<String> in post method using Spring MVC? Http Post request with content type application/x-www-form-urlencoded not working in Spring How to send a POST request using volley with string body? REST API - file (ie images) processing - best practices No 'Access-Control-Allow-Origin' header is present on the requested resource - Resteasy How to set base url for rest in spring boot? Add my custom http header to Spring RestTemplate request / extend RestTemplate CORS with spring-boot and angularjs not working How do I retrieve query parameters in Spring Boot? Spring Boot: Cannot access REST Controller on localhost (404) How to solve maven 2.6 resource plugin dependency? When do I use path params vs. query params in a RESTful API? Spring MVC - How to return simple String as JSON in Rest Controller What is the difference between resource and endpoint? How to download a file using a Java REST service and a data stream For Restful API, can GET method use json data? can you add HTTPS functionality to a python flask web server? How to send post request to the below post method using postman rest client How do I call REST API from an android app? Trying to use Spring Boot REST to Read JSON String from POST InsecurePlatformWarning: A true SSLContext object is not available. This prevents urllib3 from configuring SSL appropriately Convert a object into JSON in REST service by Spring MVC Date format in the json output using spring boot Asp.Net WebApi2 Enable CORS not working with AspNet.WebApi.Cors 5.2.3 How to export specific request to file using postman? Spring Boot REST service exception handling

Questions with http-post tag:

Passing headers with axios POST request How to post raw body data with curl? Send FormData with other field in AngularJS How do I POST a x-www-form-urlencoded request using Fetch? OkHttp Post Body as JSON What is the difference between PUT, POST and PATCH? HTTP Request in Swift with POST method Uploading file using POST request in Node.js Send POST request with JSON data using Volley AngularJS $http-post - convert binary to excel file and download Simple C example of doing an HTTP POST and consuming the response How to POST raw whole JSON in the body of a Retrofit request? Uploading Images to Server android How to Get the HTTP Post data in C#? Spring MVC - Why not able to use @RequestBody and @RequestParam together Simple post to Web Api How do I print the content of httprequest request? How to simulate POST request? How to POST URL in data of a curl request Sending an HTTP POST request on iOS Node.js - How to send data from html to express $_POST not working. "Notice: Undefined index: username..." How to add parameters to HttpURLConnection using POST using NameValuePair How to set a Header field on POST a form? ios Upload Image and Text using HTTP POST Get all variables sent with POST? How to use parameters with HttpPost Reading file input from a multipart/form-data POST Access POST values in Symfony2 request object Should I URL-encode POST data? Send request to curl with post data sourced from a file Pure JavaScript Send POST Data Without a Form How can I use JQuery to post JSON data? Send json post using php How can I pass POST parameters in a URL? Using HttpClient and HttpPost in Android with post parameters submit a form in a new tab How to retrieve form values from HTTPPOST, dictionary or? Logging POST data from $request_body How to manually send HTTP POST requests from Firefox or Chrome browser? Android, Java: HTTP POST Request How to use type: "POST" in jsonp ajax call How to process POST data in Node.js? .NET: Simplest way to send POST with data and read response Is there a max size for POST parameter content? Prevent double submission of forms in jQuery How to post data in PHP using file_get_contents? Getting a POST variable PHP + curl, HTTP POST sample code? Values of disabled inputs will not be submitted

Questions with retrofit tag:

Call another rest api from my server in Spring-Boot Retrofit 2: Get JSON from Response body Use JsonReader.setLenient(true) to accept malformed JSON at line 1 column 1 path $ Retrofit 2 - URL Query Parameter POST Multipart Form Data using Retrofit 2.0 including image How to get response as String using retrofit without using GSON or any other library in android Adding header to all request with Retrofit 2 Retrofit 2 - Dynamic URL Retrofit 2.0 how to get deserialised error response.body Logging with Retrofit 2 How to add headers to OkHttp request interceptor? javax.net.ssl.SSLException: Read error: ssl=0x9524b800: I/O error during system call, Connection reset by peer Send Post Request with params using Retrofit How to set timeout in Retrofit library? CertPathValidatorException : Trust anchor for certificate path not found - Retrofit Android Retrofit and GET using parameters How to log request and response body with Retrofit-Android? How to POST raw whole JSON in the body of a Retrofit request? javax.net.ssl.SSLHandshakeException: java.security.cert.CertPathValidatorException: Trust anchor for certification path not found Comparison of Android Web Service and Networking libraries: OKHTTP, Retrofit and Volley

Questions with android-json tag:

Send POST request with JSON data using Volley How to POST raw whole JSON in the body of a Retrofit request?