How to check the Android SDK version: a detailed guide for all platforms

Detecting the version Android SDK is a basic task for developers, testers and even advanced users working with customizing firmware or debugging applications. Without an accurate version number, it is impossible to guarantee tool compatibility, properly configure the build environment, or diagnose errors. For example, if you use Gradle with an outdated version of the SDK, the project may simply refuse to compile, producing mysterious errors about library incompatibility.

The problem is complicated by the fact that Android SDK consists of several components: itself SDK Tools, Platform Tools, Build Tools and packages for specific versions of Android (for example Android 14 (API 34)). Each of them is updated independently, and their versions may not be the same. In this article we will analyze all the current verification methods - from the graphical interface Android Studio to the command line, and also explain which numbers are important for your task.

1. Checking the SDK version through Android Studio

The most visual and intuitive method is to use the built-in tools Android Studio. This method is suitable for both beginners and experienced developers, since it does not require knowledge of commands or file paths. Here are the step-by-step guide:

Open Android Studio and go to the menu File → Settings (to macOS: Android Studio → Preferences). In the left side menu, select Appearance & Behavior → System Settings → Android SDK. Here you will see two key tabs:

• 📌 SDK Platforms — a list of installed versions of Android (for example, Android 13 (Tiramisu) with API 33). This displays the target platformsapplications for which you can build applications.
• 🔧 SDK Tools —toolkit components such as Android SDK Build-Tools, Android Emulator or Platform-Tools. This is where the versions are indicated tools, not platforms.

Open SDK settings|View the SDK Platforms tab|Check versions in SDK Tools|Check with project requirements-->

Pay attention to column Version —the current numbers are indicated here. For example, for Android SDK Platform-Tools it could be 34.0.4 (at the time of writing). If you need a version of a specific platform (for example, for parameter compileSdkVersion v Gradle), look for it in the section SDK Platforms.

⚠️ Attention: Versions of components in Android Studio may be automatically updated when you start the IDE. If you need a specific version for build reproducibility, disable auto-updates in settings or use SDK Manager from the command line.

2. Command line: adb and sdkmanager

For those who prefer a terminal or work on servers without a GUI, there are two main tools: adb (for devices) and sdkmanager (for local SDK). The first will help you find out the version Android SDKinstalled on the connected device, and the second - the version of the tools on your computer.

To check the version Platform-Tools (which includes adb), run in the terminal:

adb --version

The output will be similar to:

Android Debug Bridge version 1.0.41
Version 34.0.4-10406667
Installed as /Users/username/Library/Android/sdk/platform-tools/adb

The key line here is Version 34.0.4-10406667. The first two digits (34.0.4) indicate the version Platform-Tools, and the rest is the internal build.

To check all installed SDKs, use:

sdkmanager --list

This command will display a complete list of components with versions, including Build-Tools, Emulator and platforms. For example:

Path                        | Version | Description                                | Location
----                        | ------- | -----------                                | --------
build-tools;34.0.0          | 34.0.0  | Android SDK Build-Tools 34                 | build-tools/34.0.0
platform-tools              | 34.0.4  | Android SDK Platform-Tools                | platform-tools
platforms;android-34        | 3       | Android SDK Platform 34                   | platforms/android-34

3. SDK version on a physical device or emulator

Sometimes you need to find out the version Android SDKthat is used on the device itself (smartphone, tablet) or in the emulator. This is relevant for debugging when the application behaves differently on different versions of the API. The methods depend on the type of device:

• 📱 Physical device: Go to Settings → About phone → Software information. Look for the line Android version (for example, 14) and Number assembly (for example, UP1A.231005.007). The first number is API Level (for Android 14 it is 34).
• 🖥️ Android Studio Emulator: Launch the emulator, open Settings → About tablet and find Android version. Or use the command adb shell getprop ro.build.version.sdk for the exact API Level.

To programmatically determine the SDK version in the application code use:

int sdkVersion = android.os.Build.VERSION.SDK_INT;
// Will return an integer, for example 34 for Android 14

⚠️ Attention: On some custom firmware (for example, LineageOS or Pixel Experience), the build number may not correspond to official Google versions. In this case, check the API Level compliance table at apilevels.com.

4. Checking the version through the file system

All components Android SDK are stored in a local folder on your computer. The path depends on the operating system:

To find out the version Platform-Tools:

1. Go to the folder platform-tools at the path indicated above.
2. Find the file source.properties and open it with any text editor.
3. Look for the line Pkg.Revision - its value (for example, 34.0.4) is current version.

For Build-Tools a similar file is located in folders like build-tools/34.0.0/source.properties. This method is useful if sdkmanager is unavailable for some reason.

5. SDK version in a Gradle project

For developers working with Android Gradle Plugin, the SDK version is often specified directly in the project files. This is critical to build reproducibility, especially in teams. Main parameters:

• 📝 compileSdkVersion — Android version for which the application is compiled (for example, 34 for Android 14).
• 🛠️ buildToolsVersion —version Build-Tools (for example, "34.0.0").
• 🎯 minSdkVersion and targetSdkVersion —minimal and target versions, respectively.

Example from file build.gradle (Module: app):

android {
compileSdkVersion 34
buildToolsVersion "34.0.0"

defaultConfig {
minSdkVersion 24
targetSdkVersion 34
}
}

If these values do not match the installed SDK versions, Gradle may produce errors like Failed to find Build Tools revision 34.0.0In this case, update the components via SDK Manager or change the versions in build.gradle.

Through Android Studio|In the command line|In Gradle files|Look in the SDK folder|Another method-->

6. Alternative methods: environment variables and scripts

To automate checking the SDK version, you can use scripts or variables. environment. This is convenient in CI/CD pipelines (for example, GitHub Actions or Jenkins), where you need to dynamically obtain the version of the tools.

An example of a bash script for displaying the version Platform-Tools:

#!/bin/bash
PLATFORM_TOOLS_PATH="$ANDROID_HOME/platform-tools"
if [ -f "$PLATFORM_TOOLS_PATH/source.properties" ]; then
VERSION=$(grep "Pkg.Revision" "$PLATFORM_TOOLS_PATH/source.properties" | cut -d'=' -f2)
echo "Android SDK Platform-Tools version: $VERSION"
else
echo "Platform-Tools not found at $PLATFORM_TOOLS_PATH"
fi

For Windows (PowerShell):

$platformToolsPath = "$env:LOCALAPPDATA\Android\Sdk\platform-tools"
$version = Select-String -Path "$platformToolsPath\source.properties" -Pattern "Pkg.Revision=(\d+\.\d+\.\d+)"
Write-Host "Android SDK Platform-Tools version: $($version.Matches.Groups[1].Value)"

These scripts can be used integrate into build processes or use for logging versions in monitoring systems. For example, if your CI requires a specific version Build-Tools, the script will help validate the environment before launching tasks.

7. Frequent errors and their solutions

When working with versions Android SDK developers often encounter typical problems. Here are the most common ones and how to fix them:

• ❌ Error: "Failed to find Build Tools revision X.Y.Z"
  Solution: Install the missing version via SDK Manager or update buildToolsVersion to build.gradle to the available version. Check the list of installed versions with the command sdkmanager --list.
• ❌ ADB is not recognized in the terminal
  Solution: Add path to platform-tools to variable PATH or use the full path to adb (for example /Users/username/Library/Android/sdk/platform-tools/adb).
• ❌ Different SDK versions on the device and in the project
  Solution: Make sure that targetSdkVersion in build.gradle corresponds to the Android version on the test device. For emulators, create a new one with the required API Level.

Another common problem is version conflicts when working in a team. For example, if one developer uses buildToolsVersion "33.0.0"and another. — "34.0.0", the project can be built in different ways. To avoid this:

1. Fix the SDK versions in a file gradle.properties:

ANDROID_BUILD_TOOLS_VERSION=34.0.0
ANDROID_COMPILE_SDK_VERSION=34

2. Use Gradle Wrapper with a fixed version of Gradle.
3. Document the environment requirements in README.md project.

⚠️ Attention: When updating Android Studio old versions of the SDK may be marked as outdated (ObsoleteThis does not mean that they will stop working, but Google recommends switching to the latest versions to obtain them). security fixes and new features.

FAQ: Frequently asked questions about the Android SDK version

INSTALL_FAILED_OLDER_SDK: Failed to finalize session