How to send a HTTP-delete with a body in retrofit?

Question

When I try to create a delete method:

public interface ImageService {
    @DELETE("api/v1/attachment")
    Call<BaseResponse> delete(@Body DeleteModel deleteModel);
}

I get the error which basically boils down to these lines from the stacktrace:

E/AndroidRuntime: FATAL EXCEPTION: main
java.lang.RuntimeException: Failure delivering result
java.lang.IllegalArgumentException: Non-body HTTP method cannot contain @Body.
Caused by: java.lang.IllegalArgumentException: Non-body HTTP method cannot contain @Body.

How can I add a body to a delete method ?

I have searched here but found 3 not answers and nothing using retrofit.

score 96 · Accepted Answer · edited May 14 '20 at 20:15

96

A more simplified answer.

@HTTP(method = "DELETE", path = "/api/analysis_delete", hasBody = true)
Call<Analysis_Delete_RequestResult_Api10> analysis_delete_api10(@Field("seq") String seq);

This will do the trick.

edited May 14 '20 at 20:15

murgupluoglu

6,524
4
33
43

answered Jan 13 '17 at 07:36

March3April4

2,131
1
18
37

10

If you need to send @ Body, you need to remove @ FormUrlEncoded. – sunlover3 Jul 21 '17 at 15:20
1

@sunlover3 spot on! – Virat18 Apr 30 '19 at 06:22
Totally works, thanks. Btw no need to @FormUrlEncoded as sunlover3 said. – Yucel Bayram Aug 26 '19 at 06:25
Appreciate you help,Thank you so much! – Hetal May 05 '20 at 06:36
This workaround is throwing an error for me: "retrofit.RetrofitError: UserService.delete: HTTP method annotation is required (e.g., @ GET, @ POST, etc.)." – Donki Dec 18 '20 at 13:16
not working for me – Khadija Hameed Aug 26 '22 at 15:23

score 19 · Answer 2 · edited Dec 07 '17 at 10:43

19

Here is my version

@HTTP(method = "DELETE", path = "{login}", hasBody = true)
Call<ResponseBody> getData(@Path("login") String postfix, @Body Map<String, Object> options);

edited Dec 07 '17 at 10:43

Jens Borrisholt

6,174
1
33
67

answered Dec 07 '17 at 05:58

Sharanjeet Kaur

796
13
18

score 14 · Answer 3 · answered Mar 26 '18 at 11:56

Here's an excerpt from the docs, it's a documented feature of the HTTP annotation.

This annotation can also used for sending DELETE with a request body:

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

https://square.github.io/retrofit/2.x/retrofit/retrofit2/http/HTTP.html

Yftach · Answer 4 · 2018-12-03T10:10:55.677

In case you are you are using an old version that doesn't support @HTTP, you can also add another interface that implements the @RestMethod

import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import retrofit.http.RestMethod;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/** Make a DELETE request to a REST path relative to base URL with body. */
@Target(METHOD)
@Retention(RUNTIME)
@RestMethod(value = "DELETE", hasBody = true)
public @interface DELETEWITHBODY {
  String value();
}

And then the usage becomes:

public interface ImageService {
    @DELETEWITHBODY("api/v1/attachment")
    Call<BaseResponse> delete(@Body DeleteModel deleteModel);
}

score 2 · Answer 5 · answered Dec 19 '22 at 18:37

This works for me (Kotlin)

for deleting multiple objects (as key-value pair)

@HTTP(method = "DELETE", path = "api/v1/attachment", hasBody = true)
fun getData(@Body requestBody: Map<String, DeleteModel>): Callable<ResponseBody>

Or for deleting one object

@HTTP(method = "DELETE", path = "api/v1/attachment", hasBody = true)
fun getData(@Body requestBody: DeleteModel): Callable<ResponseBody>

score 0 · Answer 6 · answered Jan 06 '17 at 15:50

the service:

public interface ImageService {
    @Post("api/v1/attachment")
    Call<BaseResponse> delete(@Body DeleteModel deleteModel);
}

and in the servercontroller

import okhttp3.Request;

private final class ApiInterceptor implements Interceptor {

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request oldRequest = chain.request();
        Request.Builder builder = oldRequest.newBuilder();
        if(condition) {
            return chain.proceed(builder.build().newBuilder().delete(builder.build().body()).build());
        }
        return chain.proceed(builder.build());
    }
}

you have to trigger condition, via something and potentially have to do some filtering for the url/header/body to remove the trigger,

unless the delete url/body/header is unique enough to not collide with post or get requests.

score 0 · Answer 7 · answered Jul 15 '20 at 17:10

Originally answered here : https://stackoverflow.com/a/62920127/8956093

Kotlin Code :

path is not required if your first argument to interface method is a url annotated with @Url Example :

@HTTP(method = "DELETE", hasBody = true)
fun deleteStudentFromDatabase(
    @Url url: String,
    @Body payload: StudentModel
 ): Observable<Any>

If first argument to interface method is not a url then use this

    @HTTP(method = "DELETE", path = "{urlPath}", hasBody = true)
    fun deleteStudentFromDatabase(
        @Body payload: StudentModel,
        @Path("urlPath") url: String
     ): Observable<Any>

score 0 · Answer 8 · answered Jul 07 '22 at 19:26

0

I faced the same issue, I hope it will help others

I use: Kotlin, Retrofit, Coroutines

@FormUrlEncoded
@HTTP(method = "DELETE", path = "your_end_point_path", hasBody = true)
suspend fun delete(
    @Field("id") id: String
): Response<BaseResponse<*>>

answered Jul 07 '22 at 19:26

Eng.OsamaYousef

458
2
5
10

How to send a HTTP-delete with a body in retrofit?

8 Answers8

Linked