Get In Touch
1201 3rd Avenue Seattle, WA 98101, US
(HQ) Av. Punto Sur 31, Tlajomulco de Zúñiga, Jal 45050, MX
Carrera 11B # 99 - 25, Btá, 110221, CO
Let's talk
Ph: +1 (650) 603 0883
Sales attention M - F 9am - 5pm (CT)
Get support
Endless inspiration and meaningful work
See open positions

Retrofit. The easy way to make HTTP requests

There are a lot of ways to make HTTP request on Android. However, so far the easiest way I have found to do so is Retrofit. 


This a Java/Android client by Square, Inc. that allows you to convert your HTTP Api to a java interface.

Let’s see a quick sample of how we can create a simple API:

First thing to do is add the dependencies to our project, We can do that by adding the next couple of lines to our project gradle file.

implementation 'com.squareup.retrofit2:retrofit:2.5.0'
implementation 'com.squareup.retrofit2:converter-gson:2.5.0'

The first line is the one that is going to import the retrofit library to our project, the second one is going to allow us to parse the response as a Json Object.

Another important thing is to add the internet permission on our manifest.

<uses-permission android:name="android.permission.INTERNET"/>

So with this basic configurations done, now We are ready to start building our first test API with Retrofit.

What We are going to do is use httpbin as our test server. We will use the endpoint “https://httpbin.org/get” which is going to return us a json object as a response.

In order to start constructing our API, We need to create a new class, which in my case I called API.

In this class, We are going to do several things:

  • Declare an interface which is going to be our API declaration (in this case I called it “Api”, and contains out “testGet” http request declaration).
  • Declare the interface that We will use to handle the response of our http calls in whatever class we call them (in my case I called “RequestListener”).
  • Declare the interface that is going to receive the response from the http call (called “ApiCallback”).
  • Declare a public method, which is the one that We’ll call in order to do the http request and that takes as parameters the context and the RequestListener implementation (“testGet”).
  • And finally, our API constructor. This will contains the declaration of our Retrofit instance, and we use this instance to instantiate out API declaration.

So after all of this, our file should look something like this:

public class API {

    private final Api api;

    public API() {
        Retrofit retrofit = new Retrofit.Builder()
        api = retrofit.create(Api.class);

    public void testGet(Context context, 
       RequestListener<JsonElement> listener) {

    public interface Api {
        Call<JsonElement> testGet();

    public interface RequestListener<T> {
        void onSuccess(T response);

        void onResponse();

        void onError();

    public class ApiCallback<T> implements Callback<T> {
        protected RequestListener<T> listener;
        protected Context context;

        public ApiCallback(Context context, RequestListener<T> listener) {
            this.listener = listener;
            this.context = context;

        public void onResponse(Call<T> call, retrofit2.Response<T> response) {



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

After that, all We need to do is create an instance of out API class and call the method getTest.

    protected void onCreate(Bundle savedInstanceState) {

        API api = new API();
        api.testGet(this, new API.RequestListener<JsonElement>() {
            public void onSuccess(JsonElement response) {

            public void onResponse() {


            public void onError() {


as a result, something like this should appear on your logcat console:

RETROFIT: {"args":{},"headers":{"Accept-Encoding":"gzip","Host":"httpbin.org","User-Agent":"okhttp/3.12.0"},"origin":",","url":"https://httpbin.org/get"}

And that is basically it! Fast and easy, right? In just in a few minutes, we built an API.

In this case, we are using an HTTP call without parameters to show how it works. However, Retrofit allows you to use any HTTP method (GET, POST, PUT, DELETE), and you can add queries, a body, multipart requests, parameters within the URL, and everything you need.

Eduardo Rodriguez
Eduardo Rodriguez

We use cookies to give you the best experience. Cookie Policy