By clicking the polygon, you can also see its corresponding field on the right side.
| Limit Type | All Paid Plans | Free Trial |
|---|---|---|
| Document File Size | 50 MB | 50 MB |
| Number of Pages | 50 pages | 10 pages |
| Zip File Size | 100 MB | 100 MB |
Does Mindee use my documents for training?
No, all documents are the property of their organization and are not used for training Mindee models. We only use your documents internally to help us resolve a ticket you opened with our support team. Since we don't have access to documents sent by API, we would ask you explicitly for samples during the support request investigation, if needed.Are my documents or their data shared or sold to 3rd parties?
No, never. Documents and their data are only accessible to the users of the organization that the model belongs to. Mindee never sells documents or their data to 3rd parties.Is Mindee GDPR & SOC 2 Type II compliant?
Yes. Mindee V2 is fully GDPR-compliant and maintains its SOC 2 Type II certification, ensuring rigorous security controls, data protection standards, and transparency for enterprise needs.Can I request data deletion at any time?
Yes. You can request full or partial data deletion at any time by using the deletion features available in your [model settings](/models/model-settings#delete-the-model), [organization settings](/account-management/organizations#delete-organization), or [account settings](/account-management/account-settings#delete-account). Mindee ensures that your data is securely and permanently removed upon request. You can also contact our support team if you are unsure.Can you sign a BAA for HIPAA compliance?
We can, however these agreements are limited to enterprise users. If you have an enterprise plan, contact your dedicated account manager for more information.| Field Type | Description |
|---|---|
| Text | A sequence of characters representing textual data, a string value. |
| Number | Numeric data which can be a whole value (integer) or a decimal value (floating point). |
| Date | A specific year, month, and day, formatted as a YYYY-MM-DD date or YYYY-MM-DD HH:mm:ss for date and time. |
| Classification | A defined list of categories or types to match. Category names are text strings. |
| Boolean | Represents two possible values: Should be used for checkboxes. Hint: boolean field names should start with "is" or "has". |
| Nested Object | A complex data type containing multiple subfields or properties. Used to group related elements, such as the components of an address. Subfields may contain a single value or a list of values. Only one level of nesting: subfields may not be nested objects. |
| Object Detection | Detect the location of a document feature, such as a logo, signature, photo, etc. |
| Barcode | Detect the location of a 1D barcode (i.e. UPC, EAN) or a 2D barcode (i.e. QR Code, Data Matrix, 2D-DOC, PDF417). Additionally, attempt to decode the contents of the barcode as a string value. |
| Field Name | Field Type | Example Return Value |
|---|---|---|
| Supplier Name | String | Acme Supplies Ltd. |
| Supplier Logo | Object Detection | Polygon around the logo |
| Supplier Company Registration | Nested Object | See sub-fields below |
| Supplier Company Registration.Number | String | CRN-20250123 |
| Supplier Company Registration.Type | Classification | VAT NUMBER |
| Invoice Date | Date | 2025-06-10 |
| Is Past Due | Boolean | false |
| Total Amount | Number | 1540.75 |
| Taxes | Nested Objects Array | See sub-fields below |
| Taxes[0].Rate | number | 0.185 |
| Taxes[0].Base | number | 1300.00 |
| Taxes[0].Amount | number | 240.75 |
| Property | Normal Field Usage | Object Detection Usage |
|---|---|---|
| Name | Most important | Not used |
| Title | Important | Most important |
| Description | Complementary | Not used |
| Guidelines | Complementary | Not used |
| Classification Values | Very important (only for classification fields) | Not used |
When should I use Data Schema guidelines vs RAG guidelines?
Both work in the same way to provide extra context for the model to better identify data and extract them. The major difference is *when* they are applied: If the guideline is to be applied to all documents ⇒ use the Data Schema guideline. If the guideline only applies to a specific template ⇒ use the RAG guideline.Can the model correctly interpret positions like top, bottom, etc?
Mindee models are multimodal, meaning they use both textual and visual information. As such it is possible to write guidelines conveying positional information, for example: > The supplier logo will always be at the top of the page.Can I reference a specific location or text on the page?
Each page of the document is processed as a whole, and the models have both a visual component and a textual component (multimodal models). It is therefore possible to reference other locations and texts of the page in guidelines. This is especially useful to remove ambiguity when similar data is found in multiple locations on the page. Referencing another location: > The correct phone number is below the customer name. Specifying a location and text: > The correct customer name is found in the first line of the ship-to address.Does the model work better with field information in English?
In our own testing, major European languages such as French, Spanish, or German, are comparable to English in terms of modal accuracy. In some cases, it *may* be beneficial to define the Data Schema, such as field names and descriptions, using the language present in the document. This can help improve accuracy, in particular when terms not easily translatable are used in the field definition. For example, a model for French invoices may use "TVA Intracommunautaire" as the field name rather than "Intra-Community VAT", although both will work. Best is to try both using the [Live Test](/models/live-test) feature.How is my data protected during RAG processing?
Your data remains private and isolated within your model. All documents and annotations added to your RAG database are encrypted in transit.Is my RAG data shared with other users or sold to 3rd parties?
No, never. RAG data is only accessible to the users of the organization that the model belongs to. Mindee never sells data to 3rd parties. All storage and retrieval of RAG data is done on Mindee's dedicated servers.Does Mindee use my RAG data for training?
No, all documents are the property of their organization and are not used for training Mindee models. We only use RAG data internally with your explicit knowledge and prior consent. This is limited to using your documents to help resolve a ticket you opened with our support team.What happens to my RAG database if I downgrade my plan?
We won't delete any of the files you've uploaded into your RAG document database if you downgrade, however you will not be able to modify or validate them. The guidelines you have given to your RAG documents will be taken into account in your inferences with the lower plan, even if that is above the plan's features.Your utility is now available in your **Models** tab:
{% @supademo/embed url="
async handleResponse(response, inputSource) {
const splits = response.inference.result.splits;
for (const split of splits) {
const extractedSplit = await split.extractFromInputSource(inputSource);
}
}
Your utility is now available in your **Models** tab:
Your utility is now available in your **Models** tab.
Your OCR model is now available in your **Models** tab:
Can I use the same V1 API keys in the V2?
No, V1 and V2 do not share API key information.Can I run V1 and V2 in parallel?
Yes, absolutely. Running both platforms in parallel is not only supported but recommended if you are migrating from V1 to V2. All SDKs have full support for V1 and V2 running in parallel, more information here: [Client Libraries / SDKs](/integrations/client-libraries-sdk)Do you provide a testing or staging environment?
We do not provide separate environments for development, staging, production, etc. For information on testing your models and code before deploying to production, take a look at: [#developing-and-testing](#developing-and-testing "mention")How can I export the results to CSV?
The Mindee API return contains lists of nested fields, it is an object-based format.\ The CSV format has no provisions for objects, it only has rows and columns. To convert from Mindee's object format to a CSV format, you can either remove information or output to several CSV files (or sheets). Since each model is different, and each use case is different, there is no universal way to do this conversion. It's up to you to make a mapping that conforms to your needs. You can use the [SDKs](/extraction-models/sdk-integration) for easy manipulation of objects, or set up mapping rules in your [no-code](/extraction-models/no-code-integration) solution.Can I send requests in parallel?
Yes. All clients can be used to send requests in parallel. The exact implementation is left to the user: * For Node.js, you'll want to use asynchronous processing. * For all others, you'll want to use threads or processes.Can I use the v1 and v2 APIs together?
Yes. Each client library has support for both v1 and v2 APIs. You'll need to make a separate instance of the client classes: * .NET and Java, use `MindeeClient` and `MindeeClientV2` * all others, use `Client` and `ClientV2` The code to make requests and to process results is **very different** between v1 and v2. We highly recommend having different files (or even modules) for handling each API version.Can I send only a specific page of a multi-page PDF?
Yes. All libraries have support for cutting/extracting PDF pages. For more information, consult: [Load and Adjust a File](/integrations/client-libraries-sdk/load-and-adjust-a-file#manipulate-pdf-pages).How to stop PDFs with too many pages from being sent?
**Do not use file size**, a text PDF with 200 pages can be smaller than a single photo. Much more reliable to count the actual number of pages in the PDF document. Use the built-in file metadata methods and properties to easily add business rules based on the number of pages (among other data). For more information, consult: [Load and Adjust a File](/integrations/client-libraries-sdk/load-and-adjust-a-file#source-file-metadata).I'm using a Supabase edge function, should I use the API directly?
We recommend using the Mindee [Node.js client library](https://github.com/mindee/mindee-api-nodejs) in Supabase. You can install it in your edge function(s) using `npm`.Which library features are officially supported?
Anything documented here is officially supported and is considered stable for production use. Anything in a library that is not documented here, is **not** officially supported and subject to change or removal.There is a bug with the SDK, how can I get help?
If you are encountering a persistant issue, you should try first: 1. Asking the Docs Assistant for help: 2. Asking your local agent for help by using one of our [SKILL files](/integrations/ai-coding-assistants#skill-files) After this, if you determine (or are told) there is a problem with the SDK itself, the best bet would be to open a bug report on the relevant SDK's GitHub repository: * **Python**:You can also use the "Ask" button at the top of any page in the documentation. {% endhint %} ## Before You Start You'll need to have one of the [official Mindee SDKs](/integrations/client-libraries-sdk) installed. You'll also need to use one of your [API keys](/integrations/api-keys) and have at least one [Model](/models/models-overview) configured. The client works for all model types. ## Initialize the Mindee Client Before sending any files to the Mindee servers for processing, you'll need to initialize your client. This should be the first step in your code. It will determine which organization is used to make the calls. You should reuse the same client instance for all calls of the same organization. The client instance is thread-safe in applicable languages. {% tabs %} {% tab title="Python" %} First import the needed classes: ```python from mindee.v2 import Client ``` For the API key, you can pass it directly to the client.\ This is useful for quick testing. ```python api_key = "MY_API_KEY" mindee_client = Client(api_key) ``` Instead of passing the key directly, you can also set the following environment variable: `MINDEE_V2_API_KEY` This is recommended for production use.\ In this way there is no need to pass the `api_key` when initializing the client. ```python mindee_client = Client() ``` {% endtab %} {% tab title="Node.js" %} First import the needed classes. We recommend using ES Modules. ```typescript import * as mindee from "mindee"; // If you're on CommonJS: // const mindee = require("mindee"); ``` For the API key, you can pass it directly to the client.\ This is useful for quick testing. ```typescript const apiKey = "MY_API_KEY"; const mindeeClient = new mindee.Client({ apiKey: apiKey }); ``` Instead of passing the key directly, you can also set the following environment variable: `MINDEE_V2_API_KEY` This is recommended for production use.\ In this way there is no need to pass the `apiKey` argument when initializing the client. ```typescript const mindeeClient = new mindee.Client(); ``` **Advanced Usage** internally, [undici](https://undici.nodejs.org/) is used for making HTTP calls, and when the client is initialized `getGlobalDispatcher` is called. **This is perfectly fine for the vast majority of cases:**\ If you set a custom Agent as your global dispatcher, Mindee will use it for all calls. In some rare cases you may need a specific dispatcher for Mindee, different from your global dispatcher. You can set a custom dispatcher as follows: ```javascript import { Agent, interceptors } from "undici"; // Init the custom Dispatcher // REPLACE THE LINE BELOW WITH YOUR CODE - this example will NOT work! const myDispatcher = new Agent().compose( ... ); const mindeeClient = new mindee.Client({ // Don't set if using an environment variable apiKey: apiKey, // Activates verbose logging - disable in production! debug: true, // Pass the custom dispatcher to the Mindee client dispatcher: myDispatcher, }); ``` The Mindee client will then use the given dispatcher for **all calls**. This is the recommended setup when needing to pass extra parameters or configuration options, for example when using the Client behind a proxy. When running in some serverless environments like Vercel, *sometimes* (this depends on your exact setup) there are errors caused by freezing/thawing of the process. These can be avoided by:
// Avoids stale connections accumulating in the pool.
const myDispatcher = new Agent({
// Drop idle sockets after 1 ms, effectively disables connection reuse
keepAliveTimeout: 1,
// Prevent the server from extending the window via a Keep-Alive header
keepAliveMaxTimeout: 1,
});
You can also use the "Ask" button at the top of any page in the documentation. {% endhint %} Parameters that apply to all Mindee model types (Extraction, Split, Crop, etc). Inference parameters control: * which model to use * server-side processing options All model parameter classes inherit from a base class. In these samples we will be showing the general usage and parameters common to all. All examples use the Extraction model (product in the SDK), but you'll need to adjust depending on the model type you are using. The available classes are: * `ExtractionParameters` for [Extraction](/extraction-models/extraction-models-overview) models * `SplitParameters` for [Split](/split-models/split) models * `CropParameters` for [Crop](/crop-models/crop) models * `ClassificationParameters` for [Classification](/classification-models/classification) models * `OCRParameters` or `OcrParameters` for [Raw Text OCR](/raw-text-ocr-models/ocr) models ### Use an Alias The optional `alias` argument lets you attach your own identifier to a request as a free-form string. This alias could be an internal document ID, a reference number, or a database key. It is echoed back unchanged in both the job and result responses, making it straightforward to match API responses with your own records. Aliases are not unique in Mindee, you can use the same alias value multiple times. {% tabs %} {% tab title="Python" %} ```python inference_params = ExtractionParameters( # ID of the model, required. model_id="MY_MODEL_ID", # Use an alias to link the file to your own DB. # If set, it will be included in the job and result responses. alias="internal-doc-id-123", # ... any other options ... ) ``` {% endtab %} {% tab title="Node.js" %} ```typescript const modelParams = { // ID of the model, required. modelId: "MY_MODEL_ID", // Use an alias to link the file to your own DB. // If set, it will be included in the job and result responses. alias: "internal-doc-id-123", // ... any other options ... }; ``` {% endtab %} {% tab title="PHP" %} ```php $modelParams = new ExtractionParameters( // ID of the model, required. "MY_MODEL_ID", // Use an alias to link the file to your own DB. // If set, it will be included in the job and result responses. alias: "internal-doc-id-123", // ... any other options ... ); ``` {% endtab %} {% tab title="Ruby" %} ```ruby inference_params = { # ID of the model, required. model_id: 'MY_MODEL_ID', # Use an alias to link the file to your own DB. # If set, it will be included in the job and result responses. file_alias: 'internal-doc-id-123', # ... any other options ... } ``` {% endtab %} {% tab title="Java" %} ```java var modelParams = ExtractionParameters // ID of the model, required. .builder("MY_MODEL_ID") // Use an alias to link the file to your own DB. // If set, it will be included in the job and result responses. .alias("internal-doc-id-123") // ... any other options ... // complete the builder .build(); ``` {% endtab %} {% tab title=".NET" %} ```csharp var modelParams = new ExtractionParameters( // ID of the model, required. modelId: "MY_MODEL_ID" // Use an alias to link the file to your own DB. // If set, it will be included in the job and result responses. , alias: "internal-doc-id-123" // ... any other options ... ); ``` {% endtab %} {% endtabs %} # Load and Adjust a File Reference documentation on loading and manipulating files prior to sending, using Mindee client libraries. {% hint style="info" %} **This is reference documentation.** Code samples shown are only examples, and will not work as-is.\ You'll need to copy-paste and modify according to your requirements. Looking full code samples? \
You can also use the "Ask" button at the top of any page in the documentation. {% endhint %} ## Before Starting In most cases you'll be loading a source file for use in the Mindee Client. Initialize your client as described in the section: [Client Configuration](/integrations/client-libraries-sdk/configure-the-client). However, you don't actually need the client initialized to use these features, only the client library installed. ## Overview Overall, the steps to sending a file are: 1. Load a source file. 2. *Optional*: adjust the source file before sending. 3. Use the Mindee client instance to send the file. ## Load a Source File You can load a source file from a path, from raw bytes, from a bytes stream, or from a language-specific object. Choose the appropriate type based on your application requirements. If you're unsure of which to use, we recommend loading from a path. {% tabs %} {% tab title="Python" %} To load a file, you'll need to import the corresponding input class from the `mindee` module. To load a path string, use `PathInput` . ```python from mindee import PathInput input_path = "/path/to/the/file.ext" input_source = PathInput(input_path) ``` To load a `Path` instance, use `PathInput`. ```python from pathlib import Path from mindee import PathInput input_path = Path("/path/to/the/file.ext") input_source = PathInput(input_path) ``` To load raw bytes, use `BytesInput` . The `filename` parameter is required. ```python from pathlib import Path from mindee import BytesInput input_path = Path("/path/to/the/file.ext") with input_path.open("rb") as fh: input_bytes = fh.read() input_source = BytesInput( input_bytes, filename="file.ext", ) ``` To load a base-64 string, use `Base64Input` . The `filename` parameter is required.\ The string will be decoded into bytes internally. ```python from mindee import Base64Input input_base64 = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ..." input_source = Base64Input( input_base64, filename="file.ext", ) ``` To load a file handle, use `FileInput`.\ It **must** be opened in binary mode, as a `BinaryIO` . ```python from pathlib import Path from mindee import FileInput input_path = Path("/path/to/the/file.ext") with input_path.open("rb") as fh: input_source = FileInput(fh) # IMPORTANT: # Continue all operations inside the 'with' statement. response = mindee_client.enqueue_and_get_result( InferenceResponse, input_source, params, ) ``` {% endtab %} {% tab title="Node.js" %} To load a file, you'll need to import the corresponding input class and instantiate it. Make sure to import the needed classes: ```typescript import * as mindee from "mindee"; // If you're on CommonJS: // const mindee = require("mindee"); ``` To load a path string, use `PathInput`. ```typescript const filePath = "/path/to/the/file.ext"; const inputSource = new mindee.PathInput({ inputPath: filePath }); ``` To load a `Buffer` instance, use `BufferInput` . The `filename` parameter is required. ```typescript const buffer = Buffer.from( await fs.promises.readFile("/path/to/the/file.ext") ); const inputSource = new mindee.BufferInput({ buffer: buffer, filename: "file.ext", }); ``` To load raw bytes, use `BytesInput` . The `filename` parameter is required. ```typescript const inputBytes = new Uint8Array( await fs.promises.readFile("/path/to/the/file.ext") ); const inputSource = new mindee.BytesInput({ inputBytes: inputBytes, filename: "file.ext", }); ``` To load a `Stream`, use `StreamInput`. The `filename` parameter is required. ```typescript const stream = fs.createReadStream("/path/to/the/file.ext"); const inputSource = new mindee.StreamInput({ inputStream: stream, filename: "file.ext", }); ``` To load a base-64 string, use `Base64Input` . The `filename` parameter is required. ```typescript const b64String = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ..."; const inputSource = new mindee.Base64Input({ inputString: b64String, filename: "file.ext", }); ``` {% endtab %} {% tab title="PHP" %} To load a file, you'll need to import the corresponding input class from the `Mindee\Input` namespace. To load a path string, use `PathInput`. ```php use Mindee\Input\PathInput; $filePath = "/path/to/the/file.ext"; $inputSource = new PathInput($filePath); ``` To load a file resource, use `FileInput`. ```php use Mindee\Input\FileInput; $handle = fopen("/path/to/the/file.ext", "rb"); $inputSource = new FileInput($handle); ``` To load raw bytes, use `BytesInput`. The filename is required. ```php use Mindee\Input\BytesInput; $filePath = "/path/to/the/file.ext"; $handle = fopen($filePath, "rb"); $contents = fread($handle, filesize($filePath)); $inputSource = new BytesInput($contents, "file.ext"); ``` To load a base-64 string, use `Base64Input` .\ The string will be decoded into bytes internally. The filename is required. ```php use Mindee\Input\Base64Input; $inputBase64 = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ..." $inputSource = Base64Input($inputBase64, "file.ext"); ``` {% endtab %} {% tab title="Ruby" %} To load a path string, use the `PathInputSource` class. ```ruby input_path = '/path/to/the/file.ext' input_source = Mindee::Input::Source::PathInputSource.new(input_path) ``` To load raw bytes, use the `BytesInputSource` class. ```ruby input_bytes = File.binread('/path/to/the/file.ext') input_source = Mindee::Input::Source::BytesInputSource.new(input_bytes, file_name) ``` To load a base-64 string, use `Base64InputSource`. The filename is required.\ The string will be decoded into bytes internally. ```ruby input_base64 = 'iVBORw0KGgoAAAANSUhEUgAAABgAAA ...' input_source = Mindee::Input::Source::Base64InputSource.new( input_base64, 'file.ext' ) ``` To load a file handle, use `FileInputSource`. The filename is required.\ It must be opened in binary mode. ```ruby file = File.open('/path/to/the/file.ext', 'rb') input_source = Mindee::Input::Source::FileInputSource.new(file, 'file.ext') ``` {% endtab %} {% tab title="Java" %} To load a file, initialize it using the `LocalInputSource` class. This class has different constructors to allow for opening various types of inputs. To load a path string: ```java var filePath = "/path/to/the/file.ext"; var inputSource = new LocalInputSource(filePath); ``` To load a `Path` instance: ```java var filePath = new Path("/path/to/the/file.ext"); var inputSource = new LocalInputSource(filePath); ``` To load a `File` instance: ```java var file = new File("/path/to/the/file.ext"); var inputSource = new LocalInputSource(file); ``` To load a byte array, the filename is required: ```java var fileBytes = Files.readAllBytes("/path/to/the/file.ext"); var filename = "file.ext"; var inputSource = new LocalInputSource(fileBytes, filename); ``` To load an `InputStream` instance, the filename is required: ```java var fileStream = new FileInputStream( new File("/path/to/the/file.ext") ); var filename = "file.ext"; var inputSource = new LocalInputSource(fileStream, filename); ``` To load a base-64 string, the filename is required: ```java var inputBase64 = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ..."; var filename = "file.ext"; var inputSource = new LocalInputSource(inputBase64, filename); ``` {% endtab %} {% tab title=".NET" %} To load a file, initialize it using the `LocalInputSource` class. This class has different constructors to allow for opening various types of inputs. To load a path string: ```csharp string filePath = "/path/to/the/file.ext"; var inputSource = new LocalInputSource(filePath) ``` To load a `FileInfo` instance: ```csharp FileInfo fileinfo = new FileInfo("/path/to/the/file.ext"); var inputSource = new LocalInputSource(fileinfo) ``` To load a byte array, the filename is required: ```csharp byte[] fileBytes = File.ReadAllBytes("/path/to/the/file.ext"); string filename = "file.ext"; var inputSource = new LocalInputSource(fileBytes, filename) ``` To load a `Stream` instance, the filename is required: ```csharp Stream fileStream = FileStream SourceStream = File.Open( "/path/to/the/file.ext", FileMode.Open); string filename = "file.ext"; var inputSource = new LocalInputSource(fileStream, filename) ``` {% endtab %} {% endtabs %} ## Source File Metadata Once a source file is loaded, various metadata can be accessed. These metadata are overall very similar to the ones returned by the API after a successful inference.\ If you have need of these metadata before getting the full result back from the server, this is the recommended way. This can be useful for applying business rules based on the input file, for example: * Send PDFs to one model, images to another * Don't send PDFs with too many pages * Save the filename to a database * ... Here are some code samples, using an [*input source*](/integrations/client-libraries-sdk/load-and-adjust-a-file#load-a-source-file) instance. {% tabs %} {% tab title="Python" %} ```python filename: str = input_source.filename is_pdf: bool = input_source.is_pdf number_of_pages: int = input_source.page_count ``` {% endtab %} {% tab title="Node.js" %} ```javascript // make sure to initialze the source first await inputSource.init(); const filename = inputSource.filename; const isPdf = inputSource.isPdf(); const numberOfPages = await inputSource.getPageCount(); ``` {% endtab %} {% tab title="PHP" %} ```php $filename = $inputSource->fileName; $isPdf = $inputSource->isPdf(); $numberOfPages = $inputSource->getPageCount(); ``` {% endtab %} {% tab title="Ruby" %} ```ruby filename = input_source.filename is_pdf = input_source.pdf? number_of_pages = input_source.page_count ``` {% endtab %} {% tab title="Java" %} ```java String filename = inputSource.getFilename(); boolean isPdf = inputSource.isPdf(); int numberOfPages = inputSource.getPageCount(); ``` {% endtab %} {% tab title=".NET" %} ```csharp string filename = inputSource.Filename; bool isPdf = inputSource.IsPdf(); int numberOfPages = inputSource.GetPageCount(); ``` {% endtab %} {% endtabs %} ## Adjust the Source File Optionally make changes and adjustments to the source file before sending. {% hint style="info" %} All file adjustments are applied in-memory to the source file instance. If loaded from disk, the original file is not modified. {% endhint %} ### Fix PDF Headers In some cases, PDFs will have corrupt or invalid headers.\ These files will return a 4xx HTTP error as the server will be unable to process them. You can try to fix the headers using the provided functions. **Note:** this feature is not yet available for all languages. Here are some code samples, using an [*input source*](/integrations/client-libraries-sdk/load-and-adjust-a-file#load-a-source-file) instance. {% tabs %} {% tab title="Python" %} ```python input_source.fix_pdf() ``` {% endtab %} {% tab title="PHP" %} ```php $inputSource->fixPDF(); ``` {% endtab %} {% tab title="Ruby" %} ```ruby input_source.fix_pdf! ``` {% endtab %} {% endtabs %} ### Compress Files There is no need to send excessively large files to the Mindee API. Unfortunately, many modern smartphones can take very high resolution images. We provide a way to compress images before sending to the API. Here are some code samples, using an [*input source*](/integrations/client-libraries-sdk/load-and-adjust-a-file#load-a-source-file) instance. {% tabs %} {% tab title="Python" %} Basic usage is very simple, and can be applied to both images and PDFs: ```python input_source.compress(quality=85) ``` For images, you can also set a maximum height and/or width.\ The aspect ratio will always be preserved. For example to compress and resize to no greater than 1920x1920 pixels: ```python input_source.compress( quality=85, max_width=1920, max_height=1920 ) ``` {% endtab %} {% tab title="Node.js" %} Basic usage is very simple, and can be applied to both images and PDFs: ```typescript await inputSource.compress(85); ``` For images, you can also set a maximum height and/or width.\ The aspect ratio will always be preserved. For example to compress and resize to no greater than 1920x1920 pixels: ```typescript await inputSource.compress(85, 1920, 1920); ``` {% endtab %} {% tab title="PHP" %} Basic usage is very simple, and can be applied to both images and PDFs: ```php $inputSource->compress(quality: 85); ``` For images, you can also set a maximum height and/or width.\ The aspect ratio will always be preserved. For example to compress and resize to no greater than 1920x1920 pixels: ```php $inputSource->compress( quality: 85, maxWidth: 1920, maxHeight: 1920 ); ``` {% endtab %} {% tab title="Ruby" %} Basic usage is very simple, and can be applied to both images and PDFs: ```ruby input_source.compress!(quality:85) ``` For images, you can also set a maximum height and/or width. The aspect ratio will always be preserved.\ For example to compress and resize to no greater than 1920x1920 pixels: ```ruby input_source.compress!( quality:85, max_width:1920, max_height:1920 ) ``` {% endtab %} {% tab title="Java" %} Basic usage is very simple, and can be applied to both images and PDFs: ```java inputSource.compress(85); ``` For images, you can also set a maximum height and/or width.\ The aspect ratio will always be preserved. For example to compress and resize to no greater than 1920x1920 pixels: ```java inputSource.compress(85, 1920, 1920); ``` {% endtab %} {% tab title=".NET" %} Basic usage is very simple, and can be applied to both images and PDFs: ```csharp inputSource.Compress(quality: 85); ``` For images, you can also set a maximum height and/or width.\ The aspect ratio will always be preserved. For example to compress and resize to no greater than 1920x1920 pixels: ```csharp inputSource.Compress( quality: 85, maxWidth: 1920, maxHeight: 1920); ``` {% endtab %} {% endtabs %} ### Manipulate PDF Pages In some cases, PDFs will have some superfluous pages present. For example a cover page or terms and conditions which are not useful to the desired data extraction. These extra pages count towards your billing and slow down processing. It is therefore in your best interest to remove them before sending. **Parameters:** * "Page Indexes" is required and is a list of 0-based page indexes.\ Use negative values to specify indexes starting from the end, i.e. `-1` for the last page. * "Operation" specifies whether to keep only specified pages or remove specified pages.\ One of "Keep Only" or "Remove". * "On Min Pages" is optional and specifies the minimum number of pages a document must have for the operation to take place. The value of `0` means any number of pages. Exact naming of parameters will depend on the language. Here are some code samples, using an [*input source*](/integrations/client-libraries-sdk/load-and-adjust-a-file#load-a-source-file) instance. {% tabs %} {% tab title="Python" %} ```python from mindee import PageOptions # Set the options as follows: # For all documents, keep only the first page page_options = PageOptions( operation="KEEP_ONLY", page_indexes=[0], ) # Apply in-memory input_source.apply_page_options(page_options) ``` Some other examples: ```python # Only for documents having 3 or more pages: # Keep only these pages: first, penultimate, last PageOptions( operation="KEEP_ONLY", on_min_pages=3, page_indexes=[0, -2, -1], ) # For all documents: # Remove the first page PageOptions( operation="REMOVE", page_indexes=[0], ) # Only for documents having 10 or more pages: # Remove the first 5 pages PageOptions( operation="REMOVE", on_min_pages=10, page_indexes=list(range(5)), ) ``` {% endtab %} {% tab title="Node.js" %} ```typescript // Set the options as follows: // For all documents, keep only the first page const pageOptions: mindee.PageOptions = { operation: mindee.PageOptionsOperation.KeepOnly, pageIndexes: [0], }; // Apply in-memory await inputSource.applyPageOptions(pageOptions); ``` Some other examples: ```typescript // Only for documents having 3 or more pages: // Keep only these pages: first, penultimate, last const pageOptions: mindee.PageOptions = { operation: mindee.PageOptionsOperation.KeepOnly, onMinPages: 3, pageIndexes: [0, -2, -1], }; // For all documents: // Remove the first page const pageOptions: mindee.PageOptions = { operation: mindee.PageOptionsOperation.Remove, pageIndexes: [0], }; // Only for documents having 10 or more pages: // Remove the first 5 pages const pageOptions: mindee.PageOptions = { operation: mindee.PageOptionsOperation.Remove, onMinPages: 10, pageIndexes: [0, 1, 2, 3, 4], }; ``` {% endtab %} {% tab title="PHP" %} ```php use Mindee\Input\PageOptions; use const Mindee\Input\KEEP_ONLY; // Set the options as follows: // For all documents, keep only the first page $pageOptions = new PageOptions( pageIndexes: [0], operation: KEEP_ONLY ); // Apply in-memory $inputSource->applyPageOptions($pageOptions); ``` Some other examples: ```php use Mindee\Input\PageOptions; use const Mindee\Input\KEEP_ONLY; use const Mindee\Input\REMOVE; // Only for documents having 3 or more pages: // Keep only these pages: first, penultimate, last $pageOptions = new PageOptions( pageIndexes: [0, -2, -1], operation: KEEP_ONLY, onMinPage: 3 ); // For all documents: // Remove the first page $pageOptions = new PageOptions( pageIndexes: [0], operation: REMOVE ); // Only for documents having 10 or more pages: // Remove the first 5 pages $pageOptions = new PageOptions( pageIndexes: [0, 1, 2, 3, 4], operation: REMOVE, onMinPage: 10 ); ``` {% endtab %} {% tab title="Ruby" %} ```ruby # Set the options as follows: # For all documents, keep only the first page page_options = Mindee::PageOptions.new( operation: :KEEP_ONLY, page_indexes: [0], ) # Apply in-memory input_source.apply_page_options(page_options) ``` Note: the name is `apply_page_options` instead of `apply_page_options!` even though the operation is in-place, this to harmonize with the other client libraries. Some other examples: ```ruby # Only for documents having 3 or more pages: # Keep only these pages: first, penultimate, last Mindee::PageOptions.new( operation: :KEEP_ONLY, on_min_pages: 3, page_indexes: [0, -2, -1], ) # For all documents: # Remove the first page Mindee::PageOptions.new( operation: :REMOVE, page_indexes: [0], ) # Only for documents having 10 or more pages: # Remove the first 5 pages Mindee::PageOptions.new( operation: :REMOVE, on_min_pages: 10, page_indexes: array[0..4] ) ``` {% endtab %} {% tab title="Java" %} ```java import com.mindee.input.PageOptions; import com.mindee.input.PageOptionsOperation; // Set the options as follows: // For all documents, keep only the first page var pageOptions = new PageOptions.Builder() .pageIndexes(new Integer[]{ 0 }) .operation(PageOptionsOperation.KEEP_ONLY) .build(); // Apply in-memory inputSource.applyPageOptions(pageOptions); ``` Some other examples: ```java import com.mindee.input.PageOptions; import com.mindee.input.PageOptionsOperation; // Only for documents having 3 or more pages: // Keep only these pages: first, penultimate, last var pageOptions = new PageOptions.Builder() .pageIndexes(new Integer[]{ 0, -2, -1 }) .operation(PageOptionsOperation.KEEP_ONLY) .onMinPages(3) .build(); // For all documents: // Remove the first page var pageOptions = new PageOptions.Builder() .pageIndexes(new Integer[]{ 0 }) .operation(PageOptionsOperation.REMOVE) .build(); // Only for documents having 10 or more pages: // Remove the first 5 pages var pageOptions = new PageOptions.Builder() .pageIndexes(new Integer[]{ 0, 1, 2, 3, 4 }) .operation(PageOptionsOperation.REMOVE) .onMinPages(10) .build(); ``` {% endtab %} {% tab title=".NET" %} ```csharp // Set the options as follows: // For all documents, keep only the first page var pageOptions = new PageOptions( operation: PageOptionsOperation.KeepOnly , pageIndexes: [ 0 ]); // Apply in-memory inputSource.ApplyPageOptions(pageOptions); ``` Some other examples: ```csharp // Only for documents having 3 or more pages: // Keep only these pages: first, penultimate, last new PageOptions( operation: PageOptionsOperation.KeepOnly , onMinPages: 3 , pageIndexes: new short[] { 0, -2, -1 } ); // For all documents: // Remove the first page new PageOptions( operation: PageOptionsOperation.Remove , pageIndexes: new short[] { 0 } ); // Only for documents having 10 or more pages: // Remove the first 5 pages new PageOptions( operation: PageOptionsOperation.Remove , onMinPages: 10 , pageIndexes: new short[] { 0, 1, 2, 3, 4 } ); ``` {% endtab %} {% endtabs %} # Load an URL Reference documentation on loading URLs for sending, using Mindee client libraries. {% hint style="info" %} **This is reference documentation.** Code samples shown are only examples, and will not work as-is.\ You'll need to copy-paste and modify according to your requirements. Looking full code samples? \
You can also use the "Ask" button at the top of any page in the documentation. {% endhint %} ## Overview Overall, the steps to sending an URL are: 1. Load the URL, **this does not download anything locally**. 2. *Optional*: adjust the source file before sending. 3. Use the Mindee client instance to send the file. ## Requirements In most cases you'll be loading a source file for use in the Mindee Client, take a look at the [Client Configuration](/integrations/client-libraries-sdk/configure-the-client) section for more info. However, you don't actually need the client initialized to use these features, only the client library installed. All [accepted files](/integrations/technical-limitations#accepted-files) may be used, if they adhere to the [API file limits](/integrations/technical-limitations#api-file-limits). In addition, the source URL must adhere to the following rules: * Secured using TLS (HTTPS). * Publicly available using only the URL, no authentication *headers*. * Authentication may be provided in the URL as query parameters: username+password or token.\ For example, Amazon S3 signed URLs will work. * Contents must be a binary file (raw bytes, **not** base64-encoded). * File contents cannot be encrypted. * The Mindee server will **not** follow redirections (HTTP 3xx). ## Load the URL {% tabs %} {% tab title="Python" %} Use the `URLInputSource` class. ```python from mindee import UrlInputSource input_source = UrlInputSource( "https://example.com/file.ext" ) ``` {% endtab %} {% tab title="Node.js" %} Use the `URLInput` class. ```typescript const inputSource = new mindee.UrlInput({ url: "https://example.com/file.ext" }); ``` {% endtab %} {% tab title="PHP" %} Use the `URLInputSource` class. ```php use Mindee\Input\URLInputSource; $inputSource = new URLInputSource( url: "https://example.com/file.ext" ); ``` {% endtab %} {% tab title="Ruby" %} ```ruby require 'mindee' input_source = Mindee::Input::Source::URLInputSource.new( 'https://example.com/file.ext' ) ``` {% endtab %} {% tab title="Java" %} Use the `URLInputSource` class. ```java import com.mindee.input.URLInputSource; URLInputSource inputSource = URLInputSource .builder("https://example.com/file.ext") .build(); ``` {% endtab %} {% tab title=".NET" %} Use the `URLInputSource` class. ```csharp var inputSource = new UrlInputSource( "https://example.com/file.ext"); ``` {% endtab %} {% endtabs %} # Send a File or URL Reference documentation on sending files or URLs for processing using Mindee client libraries. {% hint style="info" %} **This is reference documentation.** Code samples shown are only examples, and will not work as-is.\ You'll need to copy-paste and modify according to your requirements. Looking full code samples? \
You can also use the "Ask" button at the top of any page in the documentation. {% endhint %} ## Requirements You'll need to have your Mindee client configured correctly as described in the [Client Configuration](/integrations/client-libraries-sdk/configure-the-client) section. You can send either a local file or an URL to Mindee servers for processing. There's no difference between sending a file or an URL, both are considered valid Input Sources. ### Using a Local File You'll need a Local Input Source as described in the [Load and Adjust a File](/integrations/client-libraries-sdk/load-and-adjust-a-file) section. A local file can be manipulated and adjusted before sending, as described in the [Load and Adjust a File](/integrations/client-libraries-sdk/load-and-adjust-a-file#adjust-the-source-file) section. ### Using an URL You'll need a URL Input Source as described in the [Load an URL](/integrations/client-libraries-sdk/load-an-url) section. The contents of a URL **cannot** be manipulated locally.\ You'll need to download it to the local machine if you wish to adjust the file in any way before sending. ## Send with Polling Send a document using [polling](/integrations/polling-for-results), this is the simplest way to get started. The client library will POST the request for you, and then automatically poll the API. ### Polling Configuration Remember to use the appropriate Product/Model class, examples use `ExtractionParameters`. {% tabs %} {% tab title="Python" %} When polling you really only need to set the `model_id` . ```python model_params = ExtractionParameters(model_id="MY_MODEL_ID") ``` You can also set the various polling parameters.\ However, **we do not recommend** setting this option unless you are encountering timeout problems. ```python from mindee import PollingOptions # Use only if having timeout issues. polling_options=PollingOptions( # Initial delay before the first polling attempt. initial_delay_sec=3, # Delay between each polling attempt. delay_sec=1.5, # Total number of polling attempts. max_retries=80, ) ``` {% endtab %} {% tab title="Node.js" %} When polling you really only need to set the `modelId` . ```typescript const modelParams = {modelId: "MY_MODEL_ID"}; ``` You can also set the various polling parameters.\ However, **we do not recommend** setting this option unless you are encountering timeout problems. ```typescript // Optional, set only if having timeout issues. const pollingOptions = { // Initial delay before the first polling attempt. initialDelaySec: 3.0, // Delay between each polling attempt. delaySec: 1.5, // Total number of polling attempts. maxRetries: 80, } ``` {% endtab %} {% tab title="PHP" %} When polling you really only need to set the `modelId` . ```php $modelParams = new ExtractionParameters(modelId: "MY_MODEL_ID"); ``` You can also set the various polling parameters.\ However, **we do not recommend** setting this option unless you are encountering timeout problems. ```php use Mindee\ClientOptions\PollingOptions; // Set only if having timeout issues. $pollingOptions = new PollingOptions( // Initial delay before the first polling attempt. initialDelaySec: 3.0, // Delay between each polling attempt. delaySec: 1.5, // Total number of polling attempts. maxRetries: 80, ); ``` {% endtab %} {% tab title="Ruby" %} When polling you really only need to set the `model_id` . ```ruby model_params = { model_id: "MY_MODEL_ID" } ``` You can also set the various polling parameters.\ However, **we do not recommend** setting this option unless you are encountering timeout problems. ```ruby # Set only if having timeout issues. polling_options = { # Initial delay before the first polling attempt. initial_delay_sec: 3, # Delay between each polling attempt. delay_sec: 1.5, # Total number of polling attempts. max_retries: 80, } ``` {% endtab %} {% tab title="Java" %} When polling you really only need to set the `modelId` . ```java var modelParams = ExtractionParameters .builder("MY_MODEL_ID") .build(); ``` You can also set the various polling parameters.\ However, **we do not recommend** setting this option unless you are encountering timeout problems. ```java import com.mindee.v2.clientoptions.PollingOptions; var pollingOptions = PollingOptions .builder() // Initial delay before the first polling attempt. .initialDelaySec(3.0) // Delay between each polling attempt. .intervalSec(1.5) // Total number of polling attempts. .maxRetries(80) // complete the polling builder .build(); ``` {% endtab %} {% tab title=".NET" %} When polling you really only need to set the `modelId`. ```csharp var modelParams = new ExtractionParameters(modelId: "MY_MODEL_ID"); ``` You can also set the various polling parameters.\ However, **we do not recommend** setting this option unless you are encountering timeout problems. ```csharp using Mindee.V2.ClientOptions; var pollingOptions = new PollingOptions( // Initial delay before the first polling attempt. initialDelaySec: 3.5, // Delay between each polling attempt. intervalSec: 1.5, // Total number of polling attempts. maxRetries: 80 ); ``` {% endtab %} {% endtabs %} ### Polling Method Call You'll need a valid *input source*, one of: * a local source created in [Load and Adjust a File](/integrations/client-libraries-sdk/load-and-adjust-a-file) * a remote source created in [Load an URL](/integrations/client-libraries-sdk/load-an-url) {% tabs %} {% tab title="Python" %} The `mindee_client`, created in [Client Configuration](/integrations/client-libraries-sdk/configure-the-client). Use the `enqueue_and_get_result` method. ```python response = mindee_client.enqueue_and_get_result( InferenceResponse, input_source, model_params, ) # To easily test which data were extracted, # simply print an RST representation of the inference print(response.inference) ``` {% endtab %} {% tab title="Node.js" %} The `mindeeClient`, created in [Client Configuration](/integrations/client-libraries-sdk/configure-the-client). Use the `enqueueAndGetResult` method. Remember to use the appropriate Product/Model class, examples use `Extraction`. ```typescript const response = mindeeClient.enqueueAndGetResult( // Use the appropriate product class mindee.product.Extraction, inputSource, modelParams, // optional, set only if having timeout issues. // pollingOptions, ); // Handle the response Promise response.then((resp) => { // To easily test which data were extracted, // simply print an RST representation of the inference console.log(resp.inference.toString()); }); ``` {% endtab %} {% tab title="PHP" %} The `$mindeeClient` , created in [Client Configuration](/integrations/client-libraries-sdk/configure-the-client). Use the `enqueueAndGetResult` method. Remember to use the appropriate Product/Model class, examples use `ExtractionResponse`. ```php $response = $mindeeClient->enqueueAndGetResult( // Use the appropriate product class ExtractionResponse::class, $inputSource, $modelParams, // optional, set only if having timeout issues. // $pollingOptions ); // To easily test which data were extracted, // simply print an RST representation of the inference echo strval($response->inference); ``` {% endtab %} {% tab title="Ruby" %} The `mindee_client`, created in [Client Configuration](/integrations/client-libraries-sdk/configure-the-client). Use the `enqueue_and_get_result` method. Remember to use the appropriate Product/Model class, examples use `Extraction`. ```ruby response = mindee_client.enqueue_and_get_result( # Use the appropriate product class Mindee::V2::Product::Extraction::Extraction, input_source, model_params, # optional, set only if having timeout issues. # polling_options, ) # To easily test which data were extracted, # simply print an RST representation of the inference puts response.inference ``` {% endtab %} {% tab title="Java" %} The `mindeeClient`, created in [Client Configuration](/integrations/client-libraries-sdk/configure-the-client). Use the `enqueueAndGetResult` method. Remember to use the appropriate Product/Model class, examples use `ExtractionResponse`. ```java var response = mindeeClient.enqueueAndGetResult( // Use the appropriate product class ExtractionResponse.class, inputSource, modelParams // optional, set only if having timeout issues. // pollingOptions ); // To easily test which data were extracted, // simply print an RST representation of the inference System.out.println(response.getInference().toString()); ``` {% endtab %} {% tab title=".NET" %} The `mindeeClient`, created in [Client Configuration](/integrations/client-libraries-sdk/configure-the-client). Use the `EnqueueAndGetResultAsync` method. Remember to use the appropriate product/model class, examples use `ExtractionResponse`. ```csharp var response = await mindeeClient.EnqueueAndGetResultAsync
You can also use the "Ask" button at the top of any page in the documentation. {% endhint %} ## Requirements You'll need to have already sent a file or URL as described in the [Send a File or URL](/integrations/client-libraries-sdk/send-a-file-or-url) section. ## Overview Depending on how you've sent the file, there are two ways of obtaining the result. If you've sent via polling (or polling and webhook) you'll get the response directly in your method call. If you've sent only via webhook, you'll receive the response on your Web server. Here we'll go over how you can best process the results. ## Load From Webhook If you're using the webhook pattern, you'll need to use the payload sent to your Web server. Reading the callback data will vary greatly depending on your HTTP server.\ This is therefore beyond the scope of this example. Regardless of how you access the JSON payload sent by the Mindee servers, loading this data is done by using a LocalResponse class. Once it is loaded you can access the data in exactly the same way as a polling response. To verify the HMAC signature, you'll need the Signing Secret from the webhook:
| Type | Media Type | Extensions | Notes |
|---|---|---|---|
| JPEG | image/jpeg | jpeg, jpg | |
| PNG | image/png | png | non-animated only |
| WebP | image/webp | webp | |
| TIFF | image/tiff | tiff, tif | single page or multiple pages |
| HEIC | image/heic | heic | |
| HEIF | image/heif | heif | Single HEVC-encoded image only. |
| Limit type | All Paid Plans | Free Trial |
|---|---|---|
| File Size | 100 MB | 100 MB |
| Number of Pages | No limit | 10 pages |
| Limit Type | All Paid Plans | Free Trial |
|---|---|---|
| Document File Size | 50 MB | 50 MB |
| Number of Pages | 50 pages | 10 pages |
| Zip File Size | 100 MB | 100 MB |
| Limit Type | Limit Value |
|---|---|
| Send for Processing (POST) | 200 requests per minute |
| Polling (GET) | 1200 requests per minute Normally, this is handled by the client library. |
Can I retrieve the data if there was an error with the webhook?
Yes, under some conditions. If your server returns an error when we POST the webhook, the inference will be available on the server for some time.\ The exact time the data are stored depends on the model's [Storage Settings](/models/data-processing-policies#storage-policy), but the **minimum** time stored is 1 hour. You can make a GET request on the job ID to retrieve the data for as long as the inference is on the server. The job ID is always returned when a document is sent successfully, it's important to store this ID when using webhooks for this type of scenario.How can I set up various environments like testing, staging, production?
You can create any number of webhook endpoints: create one for each environment. In your code, add an environment variable like `MINDEE_V2_WEBHOOK_ID` and set it according to the corresponding endpoint. When sending a file for inference, [specify the webhook ID](/integrations/client-libraries-sdk/send-a-file-or-url#webhook-configuration) using the environment variable.I need to filter incoming requests, do you have a static IP?
Our outgoing webhook server (incoming for you) does have a static IP address. Enterprise customers can contact us for the IP range.| HTTP Status | Possible Reasons |
|---|---|
| 400 |
|
| 401 |
Always prefer using the provided SDKs if possible. |
| 402 |
|
| 403 |
|
| 404 |
|
| 422 |
|
| 429 |
|
| HTTP Status | Possible Reasons |
|---|---|
| 500 |
|
| Plan | Monthly price (with annual billing) | Minimum Annual Credits |
|---|---|---|
| Starter | €44 / month | 6,000 credits |
| Pro | €116 / month | 6,000 credits |
| Enterprise | Custom pricing | 500,000+ credits |
| Cover image | ||
|---|---|---|
| Free Trial |
| /files/HOim63cDgNIuonLNX94Q |
| Starter |
| /files/qy4a72TJILFTJ96UUm4d |
| Pro |
| /files/k8VYKbfRQjXmgCDwerDD |
| Enterprise |
| /files/sh7GqxdKT7GjQFLw2uCg |
How is credit use calculated?
Each file processed by Mindee will consume credits based on the number of pages contained in the uploaded file. Only files successfully processed count towards your credit consumption. The exact amount of credits used per page is available for each model. For details, consult the section: [Credit Cost](/models/pricing). Overall credit consumption can be tracked from a single dashboard. For details, consult the section: [Insights](/account-management/insights).Are there limits on the number of credits that can be consumed?
Regardless of your purchased credit volume, there are no limits to credits you can consume. This avoids any situations where you would be "locked" and unable to process more documents.Are there any differences between annual and monthly plans?
Aside from the lower price, annual subscriptions provide more flexibility in credit usage. For **annual plans**, all included credits are available at any time during the subscription year. Meaning all available credits can be used as you wish throughout the year. If you use more, they are billed as additional usage.\ \ For **monthly plans**, credits are available each month. If you use less, they are lost; if you use more, they are billed as additional usage.Can I add features from another plan (à la carte pricing)?
You cannot add features from another plan. To benefit from a particular feature, you will need to upgrade to the plan which includes it.What happens to my data if I cancel my subscription?
If you cancel your subscription, your data will be retained for 30 days to allow for potential reactivation or export. After this grace period, your documents and models will be automatically deleted, in accordance with our data lifecycle policy.Can the Mindee team add a feature I need?
Our product team is always interested in adding new features to help our users.\ [Make a feature request!](https://feedback.mindee.com/?b=682f69c9e2404756e7e68d1c) Enterprise customers can ask us directly for specific features they need.| Support | Starter | Pro | Business |
|---|---|---|---|
| Community Support feedback.mindee.com | ✅ | ✅ | ✅ |
| Chat Support | ❌ | ✅ Dedicated chat | ✅ Dedicated chat |
| Priority Support | ❌ | ❌ | ✅ Priority handling in chat |
| Role Name | Permissions Summary |
|---|---|
| Member | Add and manage models Run Live Tests Manage API keys |
| Administrator | All "Member" permissions Update organization settings |
| Owner | All "Administrator" permissions Can add and remove "Administrator" users |