• Android Video Tutorials

How to handle TransactionTooLargeException in Android?


Handling a TransactionTooLargeException in Android is a common issue that most developers have encountered. The exception usually occurs when an app is trying to send or receive a large chunk of data, which exceeds the maximum size limit of the Android operating system. If the size of the data exceeds 1MB, the TransactionTooLargeException will be thrown and the app will crash. In this article, we will discuss how to handle the TransactionTooLargeException in Android. We will discuss some of the best practices that developers should follow to prevent the exception from occurring, as well as how to handle the exception when it does happen.

What is TranscationTooLarge Exception?

A TransactionTooLargeException is an exception that is thrown when an app is attempting to send or receive a large chunk of data that exceeds the maximum size limit of the Android operating system. This usually occurs when an app is trying to process a large amount of data, such as loading a large image or downloading a large file. The maximum data size varies depending on the version of Android. For Android 5.0 and later, the maximum size is 1MB. For earlier versions, the maximum size is 1.5MB.

Different ways to handle TranscationTooLarge Exceptions

There are several different ways which we can use within our android application to handle this exception which are as follows −

  • Bundles

  • Parcelables

  • SQLite Database.

  • Compressing Data.

  • Limiting the Data using Lazy Loading Techniques

Now we will take a look at each of them and how we can handle them to avoid the TranscationTooLarge Exception within our Android application.


Bundles in android applications are generally used for passing data from one fragment to another fragment or passing data from one activity to another. Bundles allow you to group the multiple objects into one bundle object before attaching them to an intent for activity or a fragment which helps to reduce the size of each individual item which is sent across the activities, fragments or services. This also allows us to break the large items into smaller chunks that can be sent separately without crashing the application.


Parcelables are used in android to parse the data. It is an interface which is used for serializing the complex java objects into byte streams which can be passed between different activities and services using intents without giving the exception of Transaction Too Large.

SQLite Database

When we have to send a huge amount of data from one activity to another we cannot rely on sending data across intents, this will show us the exception of Transaction Too Large. For performing this operation it is better to store this huge amount of data locally on the device and later we can retrieve this data anywhere inside our application. SQLite database provides us with functionality with which we can store the data inside our application. This will be beneficial as it stores all the information in the binary form which reduces its size significantly from the original data form which would have caused issues with intent due to their size restrictions.

Compressing Data

When we are sending the data between two activities we have to consider the size of the data to be shared between these activities to avoid the Transaction Too Large Exception. To handle this we can compress the data before sending it via intents which will help to reduce its size substantially and therefore reduces the chance of triggering any exceptions related to transaction sizes exceeding the limits set by Android.

Limiting the Data using Lazy Loading Techniques

Lazy Loading is a method with which we can send small chunks of larger data through intent which reduces the chances again that any transaction related exceptions would occur to size limitations being exceeded as mentioned in this article earlier.


In conclusion, understanding how transactions work within Android applications and being aware about possible problems associated with them such as transactions exceeding maximum limits set by OS helps developers create better apps which perform well even under heavy loads. Always ensure proper error handling techniques have been put in place within projects so errors like these don't go unnoticed until it's too late & user-friendly solutions like those discussed above should help developers tackle these kinds issues effortlessly & efficiently.