How to make API call in Android?

An API (Application Programming Interface) allows software programs to communicate with each other. APIs provide a standardized set of rules that enable data or functionality from an external source to be integrated into an app. In Android development, APIs enable apps to take advantage of core platform functionality, access device hardware such as the camera or accelerometer, utilize data from other apps, and integrate services from external sources like social media sites, payment processors, or weather data providers. Using APIs allows Android developers to save time and effort compared to building all required functionality from scratch within their app. Leveraging APIs also improves consistency across apps and services for end users. Overall, APIs are essential in Android development as they facilitate app capabilities that would otherwise be extremely difficult or time consuming to implement.

Developers would want to use APIs in their Android apps for several key reasons:

– Access device hardware and core OS functionality through Android platform APIs (cite:

– Integrate data and services from third-party sources like social media, payments, transportation, etc. This expands app capabilities and enables rich experiences.

– Simplify complex app development by leveraging existing APIs rather than building from scratch. This saves significant time and effort.

– Provide a consistent user experience by utilizing standard platforms and services that users are already familiar with.

– Improve reliability by building on established, maintained APIs with wide-scale testing and support.

– Reduce costs compared to developing and maintaining proprietary app functionality.

– Enable faster time-to-market by implementing pre-built API capabilities vs. building in-house.


Before you can start making API calls in your Android app, there are a few pre-requisites you need:

Install Android Studio
Android Studio is the official integrated development environment (IDE) for Android app development. You’ll need to download and install the latest version of Android Studio on your computer. This will provide all the tools you need to build, test, and debug your Android app.

Understand basic Android development concepts
It’s important to have a basic understanding of core Android development concepts like Activities, Fragments, Intents, etc. Making API calls relies on several standard Android classes and architectures, so having familiarity with these will help you be successful.

For example, you should know how to create a basic Android app with an Activity, design the layout in XML, and display dynamic data on the screen. These skills will provide the foundation for adding API calls.

If you’re completely new to Android development, completing beginner Android training or tutorials can help ensure you have the necessary knowledge.

Finding APIs to Use

There are many popular public APIs available for Android developers to leverage in their apps. Some of the most popular options include:

The Tweeter API allows accessing Twitter data like timelines, user profiles, and tweets. It can be used to build Twitter clients or analyze Twitter data.

The YouTube API provides access to YouTube functionality like searching and uploading videos. It can be integrated to build YouTube players or upload videos from an Android app.

The Google Maps API allows displaying maps, routes, and places in an Android app. It enables building mapping and location-based apps.

Other popular public APIs include Facebook, Instagram, Reddit, Spotify, Uber, AccuWeather, and more. There are thousands of free and paid public APIs across diverse categories available for use.

API Authentication

Most APIs require some form of authentication to access and use their services. There are a few common methods for authenticating with APIs in Android:

API Keys: Many APIs use simple API keys to authenticate requests. You obtain an API key during the registration process and pass it along with each request via a query parameter or header. For example, the StackOverflow API uses an api_key parameter. See this StackOverflow post for an example.

OAuth 2.0: APIs like Google use the OAuth 2.0 protocol for authentication and authorization. With OAuth 2.0, users log in through their Google account and grant access to your application. Your app then uses the access token to make API requests. See the Android documentation for details on implementing OAuth 2.0 authentication.

Basic Authentication: Some APIs use HTTP basic authentication, where you pass a username and password with each request. For example, Medium uses basic authentication for their API. See this Medium post for an Android basic auth example.

Custom Tokens: APIs may use their own custom token schemes, where you request an access token from the API server and pass it along with each request. Always check the API’s documentation for specifics on how to authenticate.

Making a GET Request

The easiest way to make a GET request in Android is by using the HttpUrlConnection class. This allows you to interact with a web API by sending an HTTP request and handling the response.

Here is an example code snippet for making a simple GET request in Android:

URL url = new URL("");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();

// read the response
InputStream in = new BufferedInputStream(conn.getInputStream());
String response = IOUtils.toString(in, "UTF-8");

// parse JSON data
JSONObject jsonObj = new JSONObject(response); 
String name = jsonObj.getString("name");

In this example, we:

  • Construct the URL for the API endpoint
  • Open an HttpUrlConnection using the URL
  • Set the request method to GET
  • Read the response InputStream into a String
  • Parse the JSON response using the JSONObject class

The HttpUrlConnection handles all the underlying HTTP request/response work for us. This provides a simple way to make GET requests in Android.

One thing to watch out for is that network requests should not be made on the main UI thread in Android. A common pattern is to use an AsyncTask or ViewModel to make the API request on a background thread.

Making a POST Request

To make a POST request in Android, you need to send data to the API. The most common way is to use the HttpURLConnection class.

First, create a JSONObject to hold the data you want to send:

JSONObject postData = new JSONObject();
postData.put("name", "John Doe"); 
postData.put("age", 35);

Then create the HTTP connection, set the request method to POST, and add the JSON data to the request body:

URL url = new URL("");
HttpURLConnection conn = (HttpURLConnection) url.openConnection();

DataOutputStream os = new DataOutputStream(conn.getOutputStream());

Finally, read the response from the API and handle it as needed:

int responseCode = conn.getResponseCode();
if (responseCode == HttpURLConnection.HTTP_OK) {
  // Success
  BufferedReader in = new BufferedReader(
      new InputStreamReader(conn.getInputStream()));
  String line;
  while ((line = in.readLine()) != null) {
    // Process response
} else {
  // Handle error

This allows sending JSON data to the API and handling the response appropriately. See Sending POST data in Android for more details.

Using Retrofit

Retrofit is a popular open-source library developed by Square for making HTTP requests and handling responses in Android apps. Its key advantages are:

  • It converts HTTP API calls into Java interfaces
  • It handles much of the complexity behind making requests and parsing responses
  • It supports synchronous and asynchronous requests
  • It works with many popular serialization formats like JSON, protocol buffers, and XML

To use Retrofit in an Android app, first add the Retrofit dependencies in your app-level build.gradle file:

implementation 'com.squareup.retrofit2:retrofit:2.9.0'

implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

Next, create an interface with annotation methods for each API endpoint you want to call. For example:

public interface ApiInterface {


Call getUsers();


Then build a Retrofit instance and implement the interface to make network calls:

Retrofit retrofit = new Retrofit.Builder()



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

Call call = apiInterface.getUsers();

call.enqueue(new Callback() {

// handle response


This allows making API calls in a clean, concise way. See the Retrofit documentation for additional details.

Displaying API Data

Once you have retrieved the data from the API, you need to display it in your Android app. A common way to display lists of data is in a RecyclerView. To display the API data in a RecyclerView:

  1. Create a data model class that matches the structure of the API data. This will be used to hold each item in the list.
  2. Create a RecyclerView Adapter class that extends RecyclerView.Adapter. This adapter will take the list of data models and populate the views.
  3. In the adapter’s onBindViewHolder method, extract the data from each model and populate the views, like TextViews, with the data.
  4. Create a layout for each item in the list. This layout should contain the TextViews and other views to display the data for that item.
  5. Set the layout manager on the RecyclerView, for example LinearLayoutManager for a vertical list.
  6. Call adapter.notifyDataSetChanged() after getting new data to update the RecyclerView.

This allows you to display the API data in a scrollable list. You can customize the views used in the item layout to best display the data. Make sure to follow best practices for efficient RecyclerView usage and updating.


Error Handling

Network errors and errors from the API response are common when making API calls in Android. Proper error handling is crucial to provide a good user experience.

Use try-catch blocks when making network calls to handle exceptions. As noted in this article, call the API inside a try block and handle errors in the catch block.

Avoid generic catch statements. Instead, catch specific exceptions like IOException or HttpException to handle errors appropriately as recommended in this post.

For API errors, inspect the response code to determine the error. Response codes like 400, 401, 403, 404, 500 etc. indicate client errors or server errors. Handle these by showing appropriate error messages to the user.

Use custom exception classes to categorize errors and handle them in a centralized way. For example, create NetworkException or ApiException classes to group network or API errors.

Where possible, retry failed network calls with exponential backoff. This improves reliability in spotty network conditions.

Follow these best practices to gracefully handle errors from API calls in Android.

Security Considerations

When working with APIs in an Android app, it is crucial to follow security best practices to protect user data and prevent vulnerabilities. Here are some key things to keep in mind:

Storing API keys – API keys should never be hardcoded into the app code. Instead, use the Android Keystore system to securely store keys. The Keystore provides encryption and access control so keys cannot be extracted from the app (source:

HTTPS – Always use HTTPS rather than HTTP when making API calls. HTTPS provides encryption during data transmission to keep user data secure (source:

User data privacy – Only request user data that is essential for your app’s core functionality. Store as little user data as possible. Follow Google’s data safety guidelines to build privacy into your app from the start (source:

Leave a Reply

Your email address will not be published. Required fields are marked *