Process the Result

Reference documentation on processing results using the Mindee client libraries.

This is reference documentation. Looking for a quick TL;DR?

• Take a look at the Integrating Mindee page.

• Use the search bar above to ask our documentation AI to write code samples for you.

Requirements

You'll need to have already sent a file or URL as described in the 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.

Python

Assuming you're able to get the raw HTTP request via the variable request .

from mindee import LocalResponse, InferenceResponse

# Load the JSON string sent by the Mindee webhook POST callback.
local_response = LocalResponse(request.body())

# You can also load the json from a local path.
# local_response = LocalResponse("path/to/my/file.ext")

# Optionally: verify the HMAC signature
# You'll need to get the "X-Signature" custom HTTP header.
hmac_signature = request.headers.get("X-Signature")
is_valid = local_response.is_valid_hmac_signature(
    "obviously-fake-secret-key", hmac_signature
)
if not is_valid:
    raise Error("Bad HMAC signature! Is someone trying to do evil?")

# Deserialize the response into objects
response = local_response.deserialize_response(InferenceResponse)

Node.js

Assuming you're able to get the raw HTTP request via the variable request .

function handleMindeeResponse(data, hmacSignature) {
  const localResponse = new mindee.LocalResponse(data);
  const isValid = localResponse.isValidHmacSignature(
      "obviously-fake-secret-key", hmacSignature
    );
  if (!isValid) {
    throw Error("Bad HMAC signature! Is someone trying to do evil?");
  }
  const response = localResponse.deserializeResponse(
    mindee.InferenceResponse
  );
}

// Getting the data could look something like this.
// Will vary depending on your implementation.
function handleMindeePost(request, response) {
  let body = "";
  request.on("data", function (data) {
    body += data;
  });
  req.on("end", function () {
    // Optionally: verify the HMAC signature
    // You'll need to get the "X-Signature" custom HTTP header.
    const hmacSignature = request.headers.get("X-Signature");
    
    handleMindeeResponse(data, hmacSignature);
  });
}

Java

Assuming you have a Web server instance myHttpServer .

// Load the JSON string sent by the Mindee webhook POST callback.
String jsonData = myHttpServer.getPostBodyAsString();
LocalResponse localResponse = new LocalResponse(jsonData);

// Verify the HMAC signature.
// You'll need to get the "X-Signature" custom HTTP header.
String hmacSignature = myHttpServer.getHeader("X-Signature");
boolean isValid = localResponse.isValidHmacSignature(
    "obviously-fake-secret-key", hmacSignature
);
if (!isValid) {
    throw new Exception("Bad HMAC signature! Is someone trying to do evil?");
}

// You can also use a File object as the input.
//LocalResponse localResponse = new LocalResponse(
//    new File("/path/to/file.json"));

// Deserialize the response into objects
InferenceResponse response = localResponse.deserializeResponse(
    InferenceResponse.class
);

// Print a summary of the parsed data
System.out.println(response.getDocument().toString());

Accessing Fields

Fields are completely dynamic and depend on your model's Data Schema.

In the client library, you'll have access to the various fields as a mapping type (Python's dict, Java's HashMap, etc).

Accessing a field is done via its name in the Data Schema.

Each field will be one of the following types:

• A single value, SimpleField class.

• Multiple values (an object), ObjectField class.

• A list or array of fields, ListField class.

Single-Value Field - SimpleField

Basic field type having the following attributes.

value

The extracted data value. Possible types: string, number (integer or floating-point), boolean. All types can be null.

On the platform, you can specify date and classification types. These are returned as strings.

For statically-typed languages (C#, Java), the client library will always return a nullable double for number values.

.NET

Using the response deserialized object from either the polling response or a webhook payload.

using Mindee.Parsing.V2.Field;

InferenceFields fields = response.Inference.Result.Fields;

SimpleField mySimpleField = fields["my_simple_field"].SimpleField;
var fieldValue = mySimpleField.Value;

The Value attribute is a dynamic type under the hood.

You can explicitly declare the type, this is recommended for clarity. You'll need to look at your Data Schema to declare the correct type.

using Mindee.Parsing.V2.Field;

InferenceFields fields = response.Inference.Result.Fields;

// texts, dates, classifications ...
string stringFieldValue = fields["string_field"].SimpleField.Value;

// a JSON float will be a Double
Double floatFieldValue = fields["float_field"].SimpleField.Value;

// even if the API always returns an integer, the type will be Double
Double intFieldValue = fields["int_field"].SimpleField.Value;

// booleans
Boolean boolFieldValue = fields["bool_field"].SimpleField.Value;

If the wrong type is declared, an exception will be raised, something like this:

RuntimeBinderException : Cannot implicitly convert type 'string' to 'double'

confidence

The confidence level of the extracted value.

Only filled if the automation feature is activated. See the Automation (Confidence Score) section for more details.

.NET

Using the response deserialized object from either the polling response or a webhook payload.

using Mindee.Parsing.V2.Field;

InferenceFields fields = response.Inference.Result.Fields;

// nullable enum since presence depends on feature activation
FieldConfidence? confidence = fields["my_simple_field"].SimpleField.Confidence;

locations

A list of the field's locations on the document.

Only filled if the polygons feature is activated.

It's possible for a single field to have multiple locations, for example when an invoice item spans two pages.

Each location has a page index and a polygon.

.NET

Using the response deserialized object from either the polling response or a webhook payload.

using Mindee.Parsing.V2.Field;
using Mindee.Geometry;

InferenceFields fields = response.Inference.Result.Fields;

List<FieldLocation> locations = fields["my_simple_field"].SimpleField.Locations;

// there are geometry functions available in the Polygon class
Polygon polygon = locations.First().Polygon;
Point center = polygon.GetCentroid();

Multiple-Value Field - ObjectField

Each field can theoretically be of any type (single, multi, list). In practice: we limit to a single value, meaning no recursive objects nor lists.

Each sub-field will be a Single-Value Field - SimpleField.

In addition, the ObjectField itself has confidence and locations attributes.

List of Fields - ListField

Each item in the list can theoretically be of any type (single, multi, list). In practice: we limit items to be either single or multi field, meaning no lists of lists.

Each field in the list will be one of:

• Single-Value Field - SimpleField

• Multiple-Value Field - ObjectField

There will not be a mix of both types in the same list.

In addition, the ListField itself has a confidence attribute.