How can I check which SQLite library version my app is using?

Not by itself. That command reports information about the command-line executable you ran. Your application could load a different SQLite library, so the terminal result does not establish the version used by the app. [S1]

The reliable check is to ask the library through the application itself, or through a diagnostic that uses the same SQLite library the app loads. For an application using SQLite’s C API, sqlite3_libversion() returns the runtime version as text, and sqlite3_libversion_number() returns its numeric form. [S1]

Treat the command-line result as a separate comparison point, not as proof of the app’s version.

Call the runtime version functions and print their results. For example:

#include <stdio.h>
#include <sqlite3.h>

int main(void) {
    printf("SQLite runtime: %s\n", sqlite3_libversion());
    printf("SQLite runtime number: %d\n", sqlite3_libversion_number());
    return 0;
}

Run this diagnostic in the same build and environment as the application you want to check, and make sure it uses the SQLite library loaded by that application. A standalone diagnostic linked to a different build could report a different runtime version. The SQLite documentation identifies these functions as runtime-library interfaces. [S1]

Keep the output with the app build or environment you are investigating so you can tell which check it belongs to.

Record the values separately rather than assuming they mean the same thing. SQLITE_VERSION is a header macro and may describe the headers used when the application was compiled; the runtime functions report version information associated with the library itself. [S1]

A diagnostic record could look like this:

Application/build: [app name and build identifier]
Environment: [OS or deployment environment]
Runtime SQLite version: [value from sqlite3_libversion()]
Runtime version number: [value from sqlite3_libversion_number()]
Header version, if checked: [SQLITE_VERSION value]
Command-line version, if checked: [sqlite3 --version output]

Compare the runtime value with the header and command-line values, but label each clearly. The cited guidance explains the distinction for the C API; it does not provide a universal recipe for every language wrapper, platform, or packaging setup. If you use a wrapper, look for its documented way to query the version from the connection or library used by the app.

Use this order:

1. Identify the exact application build and environment you want to verify.
2. Query SQLite from inside that application, or use a diagnostic that loads the same SQLite library.
3. For the C API, capture both sqlite3_libversion() and sqlite3_libversion_number(). [S1]
4. Label any header-macro or command-line version separately; do not treat either as proof of the app’s runtime version. [S1]
5. Save the output with the build and environment identifiers, then repeat the check for other builds or deployment environments you need to compare.

If the app is not using SQLite’s C API directly, the exact version-query method depends on its wrapper or platform. The C API references alone do not establish platform-specific instructions or explain how every wrapper exposes its runtime version. [S1]