Mindee SDKs & Libraries: Official and Community Integrations (2026)

SDKs overview

Mindee offers Software Development Kits (SDKs) to simplify integration with its document processing APIs. These SDKs are designed to abstract the underlying HTTP requests and response parsing, allowing developers to interact with Mindee's services using familiar programming language constructs. The SDKs cover a range of functionalities, from uploading documents and configuring processing options to retrieving and interpreting extracted data from various document types, including invoices, receipts, and identification documents.

The primary advantage of using an SDK over direct API calls is the reduction in boilerplate code. SDKs typically handle:

• Authentication: Managing API keys and secure access to Mindee services, as detailed in the Mindee API keys documentation.
• Request Construction: Formatting requests according to Mindee's API specifications, including multipart form data for file uploads.
• Response Parsing: Deserializing JSON responses into native language objects, providing structured access to extracted fields.
• Error Handling: Standardizing error responses and providing exceptions that can be caught and managed within application logic.
• Convenience Methods: Offering high-level functions for common tasks, such as sending a document to the Mindee Invoice API or using the Mindee Custom Document API.

Mindee's SDKs are actively maintained and are generally the recommended integration method for developers working with supported languages. For languages without an official SDK, direct API integration using standard HTTP client libraries is an alternative, referencing the Mindee API reference for endpoint details.

Official SDKs by language

Mindee provides official SDKs for several popular programming languages, ensuring direct support and optimized integration paths for a broad developer base. These SDKs are maintained by Mindee and are the recommended method for interacting with their APIs. They are designed to encapsulate the complexities of HTTP requests and JSON parsing, presenting a more idiomatic interface for each language. Each SDK is typically distributed through the respective language's package manager, facilitating easy installation and dependency management.

The following table outlines the officially supported SDKs, their package names, and typical installation commands:

Each SDK provides specific client objects and methods corresponding to Mindee's various document APIs, such as those for receipts, ID cards, and passports. Developers can find detailed usage instructions and examples for each language within the Mindee SDK overview documentation.

Installation

Installing Mindee's SDKs typically involves using the standard package manager for your chosen programming language. This ensures that all necessary dependencies are resolved and the SDK is correctly integrated into your project. The following provides specific installation commands for the most commonly used SDKs:

Python

The Python SDK is distributed via PyPI. To install it, use pip:

pip install mindee

After installation, you can import the mindee package into your Python scripts. For best practices, it is recommended to install SDKs within a Python virtual environment to manage project dependencies effectively.

Node.js

The Node.js SDK is available on npm. Install it using npm or yarn:

npm install @mindee/js-sdk

or

yarn add @mindee/js-sdk

Once installed, you can import modules from @mindee/js-sdk into your JavaScript or TypeScript projects. Refer to the Mindee JavaScript SDK documentation for detailed usage examples and configuration options.

.NET

The .NET SDK is distributed as a NuGet package. You can install it using the .NET CLI:

dotnet add package MindeeSDK

Alternatively, you can use the NuGet Package Manager in Visual Studio to search for and install MindeeSDK. Comprehensive guidance is available in the Mindee .NET SDK guide.

Java

For Java projects, the Mindee SDK is available on Maven Central. You'll need to add the dependency to your project's build file (e.g., pom.xml for Maven or build.gradle for Gradle).

Maven (pom.xml):

<dependency>
    <groupId>com.mindee</groupId>
    <artifactId>mindee-api-java</artifactId&n    <version>[LATEST_VERSION]</version>
</dependency>

Gradle (build.gradle):

implementation 'com.mindee:mindee-api-java:[LATEST_VERSION]'

Replace [LATEST_VERSION] with the current version number, which can be found in the Mindee Java SDK documentation.

Quickstart example

This quickstart example demonstrates how to use the Mindee Python SDK to process a receipt image and extract structured data. Before running, ensure you have installed the Python SDK as described in the installation section and have your Mindee API key ready. You can obtain an API key from your Mindee account dashboard.

Python Receipt Processing Example

First, save your API key to an environment variable or replace 'YOUR_API_KEY' directly in the code for testing purposes. Create a Python file (e.g., process_receipt.py) and add the following code:

import os
from mindee import Client, product

# Initialize a Mindee Client
# It's recommended to set your API key as an environment variable (MINDEE_API_KEY)
# Alternatively, you can pass it directly: client = Client(api_key="YOUR_API_KEY")
client = Client()

# Load the receipt file
# Replace 'path/to/your/receipt.jpg' with the actual path to your receipt image
file_path = "./path/to/your/receipt.jpg"

# Ensure the file exists
if not os.path.exists(file_path):
    print(f"Error: File not found at {file_path}")
    exit()

# Send the document to the Mindee Receipt API
input_source = client.doc_from_path(file_path)

# Process the document using the Receipt V5 API
result = client.parse(product.ReceiptV5, input_source)

# Print the extracted data in a human-readable format
print(result.document.inference.prediction)

# Access specific fields, for example:
print(f"Total Amount: {result.document.inference.prediction.total_amount.value}")
print(f"Date: {result.document.inference.prediction.date.value}")
print(f"Supplier Name: {result.document.inference.prediction.supplier_name.value}")

# You can also iterate through line items if available
if result.document.inference.prediction.line_items:
    print("Line Items:")
    for item in result.document.inference.prediction.line_items:
        print(f"  Description: {item.description}, Quantity: {item.qty}, Total: {item.total_amount}")

To run this example:

1. Replace './path/to/your/receipt.jpg' with the actual path to an image file of a receipt.
2. Ensure your Mindee API key is set as an environment variable named MINDEE_API_KEY, or uncomment and update the client = Client(api_key="YOUR_API_KEY") line.
3. Execute the script from your terminal: python process_receipt.py

The output will display the full prediction object and then specific fields like total amount, date, and supplier name, demonstrating how Mindee's SDK simplifies accessing extracted data. This example uses the ReceiptV5 product, but similar patterns apply to other Mindee products like Invoices or ID Cards by importing the relevant product class.

Community libraries

While Mindee provides a strong set of official SDKs, the broader developer community may contribute additional libraries, wrappers, or tools that extend Mindee's functionality or integrate it into specific frameworks or platforms not directly supported by official SDKs. These community-driven projects can offer alternative language bindings, specialized utilities, or integrations with other services. They often emerge from developers addressing unique use cases or preferring different architectural approaches.

Community libraries are typically hosted on platforms like GitHub and distributed through language-specific package managers, similar to official SDKs. However, their maintenance, support, and adherence to Mindee's API changes can vary significantly compared to official offerings. Developers considering community libraries should evaluate their active development status, contributor base, licensing, and compatibility with the latest Mindee API versions.

As of May 2026, Mindee's primary focus for SDK support is on its official SDKs. Information regarding community-contributed libraries is typically found through developer forums, community discussions, or by searching repositories on platforms like GitHub for projects tagged with "Mindee" or related terms. For instance, developers often share custom integrations or helper functions in language-specific communities, which can sometimes evolve into more formal libraries. An example of a common pattern in API integration for languages without direct SDKs is to use a generic HTTP client library, such as Python's Requests library, to build custom wrappers for Mindee's REST API endpoints.

Developers are encouraged to consult the Mindee developer documentation for the most current information regarding supported SDKs and any officially recognized community initiatives.