FingerprintJS Pro SDKs & Libraries: Official and Community (2026)

SDKs overview

FingerprintJS Pro offers a suite of Software Development Kits (SDKs) and libraries designed to facilitate the integration of its device identification technology into various application environments. These SDKs handle the complexities of collecting browser and device signals, processing them to create a stable and unique visitor identifier. The architecture typically involves a client-side SDK that collects data from the end-user's device or browser and sends it to the FingerprintJS Pro API, which then returns a visitor ID. Server-side SDKs are also available to interact directly with the FingerprintJS Pro Server API for verification or advanced use cases.

The primary function of these SDKs is to abstract away the details of fingerprinting, allowing developers to focus on integrating the resulting visitor identification into their application logic. This abstraction covers aspects such as data collection, API communication, and error handling. FingerprintJS Pro maintains official SDKs for common web and mobile development platforms, alongside support for various server-side languages to enable comprehensive integration strategies across an application's stack. For specific implementation details across various platforms, refer to the FingerprintJS Pro documentation.

Official SDKs by language

FingerprintJS Pro provides official SDKs for a range of client-side and server-side environments. These SDKs are maintained by FingerprintJS and are the recommended method for integrating the service. Each SDK is designed to optimize performance and ease of use within its respective ecosystem. A comprehensive API reference is available for detailed understanding of the exposed methods and data structures.

Installation

Installation methods vary depending on the chosen SDK and development environment. The following examples cover the typical installation procedures for common platforms. For detailed and platform-specific instructions, developers should consult the official FingerprintJS Pro documentation.

Web (JavaScript SDK)

To install the FingerprintJS Pro JavaScript SDK using npm:

npm install @fingerprintjs/fingerprintjs-pro

Alternatively, for direct browser integration via CDN:

<script async src="//fpcdn.io/fp.js"></script>

Android

Add the FingerprintJS Pro Android SDK to your module's build.gradle file:

dependencies {
    implementation 'com.fingerprintjs:fingerprint-pro-android:2.0.0' // Use the latest version
}

iOS

For iOS development using CocoaPods, add the following to your Podfile:

pod 'FingerprintPro', '~> 2.0.0' # Use the latest version

Then run pod install.

React Native

Install the React Native SDK via npm or yarn:

npm install @fingerprintjs/fingerprintjs-pro-react-native
# or
yarn add @fingerprintjs/fingerprintjs-pro-react-native

npx pod-install # For iOS projects

Flutter

Add the fingerprint_pro_flutter dependency to your pubspec.yaml file:

dependencies:
  flutter:
    sdk: flutter
  fingerprint_pro_flutter: ^2.0.0 # Use the latest version

Then run flutter pub get.

Server API (Node.js)

Install the Node.js Server API SDK:

npm install @fingerprintjs/fingerprintjs-pro-server-api

Quickstart example

This quickstart demonstrates how to integrate the FingerprintJS Pro Web SDK to obtain a visitor identifier. This example assumes you have an API key and are integrating into a web application. For server-side verification and more advanced use cases, refer to the FingerprintJS Pro documentation.

JavaScript (Web SDK) Quickstart

First, ensure the SDK is installed (e.g., via npm or CDN). Then, initialize the agent and get the visitor ID:

import FingerprintJS from '@fingerprintjs/fingerprintjs-pro';

const fpPromise = FingerprintJS.load({
  apiKey: 'YOUR_PUBLIC_API_KEY_HERE' // Replace with your actual public API key
});

fpPromise
  .then(fp => fp.get())
  .then(result => {
    // This object contains the visitor ID and other data
    const visitorId = result.visitorId;
    console.log('Visitor ID:', visitorId);

    // You can send this visitorId to your backend for further processing or verification
    // fetch('/api/verify-visitor', {
    //   method: 'POST',
    //   headers: { 'Content-Type': 'application/json' },
    //   body: JSON.stringify({ visitorId: visitorId, requestId: result.requestId })
    // });
  })
  .catch(error => console.error('Error getting visitor ID:', error));

In this example, YOUR_PUBLIC_API_KEY_HERE should be replaced with a valid public API key obtained from your FingerprintJS Pro dashboard. The fp.get() method returns a promise that resolves with an object containing the visitorId and requestId, among other data points. The visitorId is the unique identifier for the user, while the requestId is a unique identifier for the specific identification event, which can be used for server-side verification.

Server-Side Verification (Node.js Example)

After obtaining the visitorId and requestId client-side, you can send them to your backend for verification using the Server API. This adds a layer of security and can prevent client-side tampering.

// Example Node.js backend route for verification

import { FingerprintJsServerApiClient, Region } from '@fingerprintjs/fingerprintjs-pro-server-api';

// Initialize the client with your private API key and region
const client = new FingerprintJsServerApiClient({
  region: Region.Global,
  apiKey: 'YOUR_PRIVATE_API_KEY_HERE' // Replace with your actual private API key
});

// Assuming this is an Express.js route
app.post('/api/verify-visitor', async (req, res) => {
  const { visitorId, requestId } = req.body;

  if (!visitorId || !requestId) {
    return res.status(400).send('Missing visitorId or requestId');
  }

  try {
    const eventResponse = await client.getEvent(requestId);

    if (eventResponse.products.identification.data.visitorId === visitorId) {
      // Visitor ID matches, further checks can be performed here
      console.log('Verification successful for visitor:', visitorId);
      res.status(200).send({ message: 'Visitor verified', data: eventResponse });
    } else {
      console.log('Verification failed: Mismatch in visitor ID');
      res.status(403).send('Visitor verification failed');
    }
  } catch (error) {
    console.error('Error during server-side verification:', error);
    res.status(500).send('Server error during verification');
  }
});

This Node.js example demonstrates how a backend service can use the requestId to retrieve the full event data from the FingerprintJS Pro Server API. It then compares the visitorId returned by the server with the one sent from the client. This process helps ensure that the client-side identification was legitimate and not spoofed. The Server API documentation provides more details on various verification scenarios and data available.

Community libraries

While FingerprintJS Pro maintains a set of official SDKs for core platforms and languages, the open-source nature of FingerprintJS (the underlying technology) sometimes encourages community contributions and libraries. However, for FingerprintJS Pro, which is a commercial offering with specific API endpoints and requirements, official SDKs are the primary and recommended integration method for ensuring compatibility, reliability, and access to the full feature set. As of 2026, the emphasis is on maintaining robust official SDKs for key development ecosystems.

Developers seeking to integrate FingerprintJS Pro into environments not directly supported by an official SDK are generally advised to use the Server API directly, or consider building a thin wrapper using official documentation as a guide. For integration with specific frameworks or languages where a community solution might be preferred, it is important to review the library's maintenance status, security practices, and alignment with the latest FingerprintJS Pro API versions. An example of a common pattern for community involvement in API integration is the development of client libraries that wrap an existing HTTP API, as seen with various Google API client libraries.

Users are encouraged to consult the FingerprintJS Pro documentation for the most up-to-date information on supported SDKs and recommended integration patterns. The official GitHub repositories for FingerprintJS Pro SDKs are also valuable resources for community discussions, issue tracking, and potential contributions under the guidance of FingerprintJS engineers.