Securibox ParseXtract:API

Securibox PX API

Securibox PX API

Docs

feedDocs

Store the provided documents for manual parsing

Store documents which were wrongly classified and/or parsed for manual classification and parsing. *extractedData* may be missing.


/docs/feed

Usage and SDK Samples

curl -X POST -H "Authorization: Basic [[basicHash]]" -H "Authorization: [[apiKey]]" "https://parse.securibox.eu/api/v1/docs/feed"
import io.swagger.client.*;
            import io.swagger.client.auth.*;
            import io.swagger.client.model.*;
            import io.swagger.client.api.DocsApi;
            
            import java.io.File;
            import java.util.*;
            
            public class DocsApiExample {
            
                public static void main(String[] args) {
                    ApiClient defaultClient = Configuration.getDefaultApiClient();
                    
                    // Configure HTTP basic authorization: basic
                    HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
                    basic.setUsername("YOUR USERNAME");
                    basic.setPassword("YOUR PASSWORD");
                    
                    // Configure API key authorization: jwt
                    ApiKeyAuth jwt = (ApiKeyAuth) defaultClient.getAuthentication("jwt");
                    jwt.setApiKey("YOUR API KEY");
                    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
                    //jwt.setApiKeyPrefix("Token");
                    
                    
            
                    DocsApi apiInstance = new DocsApi();
                    
                    array[Document] body = ; // array[Document] | 
                    
                    try {
                        array[Document] result = apiInstance.feedDocs(body);
                        System.out.println(result);
                    } catch (ApiException e) {
                        System.err.println("Exception when calling DocsApi#feedDocs");
                        e.printStackTrace();
                    }
                }
            }
import io.swagger.client.api.DocsApi;
            
            public class DocsApiExample {
            
                public static void main(String[] args) {
                    DocsApi apiInstance = new DocsApi();
                    
                    array[Document] body = ; // array[Document] | 
                    
                    try {
                        array[Document] result = apiInstance.feedDocs(body);
                        System.out.println(result);
                    } catch (ApiException e) {
                        System.err.println("Exception when calling DocsApi#feedDocs");
                        e.printStackTrace();
                    }
                }
            }

            Configuration *apiConfig = [Configuration sharedConfig];
            // Configure HTTP basic authorization (authentication scheme: basic)
            [apiConfig setUsername:@"YOUR_USERNAME"];
            [apiConfig setPassword:@"YOUR_PASSWORD"];
            
            // Configure API key authorization: (authentication scheme: jwt)
            [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
            
            
            array[Document] *body = ; // 
            
            
            DocsApi *apiInstance = [[DocsApi alloc] init];
            
            // Store the provided documents for manual parsing
            [apiInstance feedDocsWithCompletionHandler: :body
                          ^(array[Document] output, NSError* error) {
            
                                        if (output) {
                                            NSLog(@"%@", output);
                                        }
            
                                        if (error) {
                                            NSLog(@"Error: %@", error);
                                        }
                                    }];
            
var SecuriboxPxApi = require('securibox_px_api');
            
            var defaultClient = SecuriboxPxApi.ApiClient.instance;
            
            // Configure HTTP basic authorization: basic
            var basic = defaultClient.authentications['basic'];
            basic.username = 'YOUR USERNAME'
            basic.password = 'YOUR PASSWORD'
            
            // Configure API key authorization: jwt
            var jwt = defaultClient.authentications['jwt'];
            jwt.apiKey = "YOUR API KEY"
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //jwt.apiKeyPrefix['Authorization'] = "Token"
            
            
            
            var api = new SecuriboxPxApi.DocsApi()
            
            var callback = function(error, data, response) {
              if (error) {
                console.error(error);
              } else {
                console.log('API called successfully. Returned data: ' + data);
              }
            };
            api.feedDocs(bodycallback);
            
            
using System;
            using System.Diagnostics;
            using IO.Swagger.Api;
            using IO.Swagger.Client;
            using IO.Swagger.Model;
            
            namespace Example
            {
                public class feedDocsExample
                {
                    public void main()
                    {
                        
                        // Configure HTTP basic authorization: basic
                        Configuration.Default.Username = "YOUR_USERNAME";
                        Configuration.Default.Password = "YOUR_PASSWORD";
                        // Configure API key authorization: jwt
                        Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                        // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                        // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
                        
            
                        var apiInstance = new DocsApi();
                        
                        
                        
                        var body = new array[Document](); // array[Document] | 
                        
                        
            
                        try
                        {
                            
                            // Store the provided documents for manual parsing
                            
                            array[Document] result = apiInstance.feedDocs(body);
                            Debug.WriteLine(result);
                        }
                        catch (Exception e)
                        {
                            Debug.Print("Exception when calling DocsApi.feedDocs: " + e.Message );
                        }
                    }
                }
            }
            
<?php
            require_once(__DIR__ . '/vendor/autoload.php');
            
            // Configure HTTP basic authorization: basic
            Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
            Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');
            // Configure API key authorization: jwt
            Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');
            
            
            $api_instance = new Swagger\Client\Api{{classname}}();
            $body = ; // array[Document] | 
            
            
            try {
                $result = $api_instance->feedDocs($body);
                print_r($result);
            } catch (Exception $e) {
                echo 'Exception when calling DocsApi->feedDocs: ', $e->getMessage(), PHP_EOL;
            }
            ?>
use Data::Dumper;
            use WWW::SwaggerClient::Configuration;
            use WWW::SwaggerClient::DocsApi;
            
            # Configure HTTP basic authorization: basic
            $WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
            $WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';
            # Configure API key authorization: jwt
            $WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
            # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            #$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";
            
            
            my $api_instance = WWW::SwaggerClient::DocsApi->new();
            my $body = [WWW::SwaggerClient::Object::array[Document]->new()]; # array[Document] | 
            
            
            eval { 
                my $result = $api_instance->feedDocs(body => $body);
                print Dumper($result);
            };
            if ($@) {
                warn "Exception when calling DocsApi->feedDocs: $@\n";
            }
from __future__ import print_statement
            import time
            import swagger_client
            from swagger_client.rest import ApiException
            from pprint import pprint
            
            # Configure HTTP basic authorization: basic
            swagger_client.configuration.username = 'YOUR_USERNAME'
            swagger_client.configuration.password = 'YOUR_PASSWORD'
            # Configure API key authorization: jwt
            swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
            # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            # swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'
            
            
            # create an instance of the API class
            api_instance = swagger_client.DocsApi()
            body =  # array[Document] | 
            
            
            try: 
                # Store the provided documents for manual parsing
                api_response = api_instance.feed_docs(body)
                pprint(api_response)
            except ApiException as e:
                print("Exception when calling DocsApi->feedDocs: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Array of documents. Documents with errors are NOT stored. Any error will be listed in the *Document.processingErrors* property.

Status: 400 - Bad request. Missing or invalid parameters.


guessDocs

Try to parse the documents based on the few data provided

Based on a few *Document.extractedData* that must be present in the input array, create a parser on-the-fly and use it to parse the entire batch. This method can be used to speed-up data entry if the application does not recognize the documents (i.e. the models were not trained on the document type you want to parse). For instance, it can help you provide new train data for the *feed* or *train* methods.


/docs/guess

Usage and SDK Samples

curl -X POST -H "Authorization: Basic [[basicHash]]" -H "Authorization: [[apiKey]]" "https://parse.securibox.eu/api/v1/docs/guess"
import io.swagger.client.*;
            import io.swagger.client.auth.*;
            import io.swagger.client.model.*;
            import io.swagger.client.api.DocsApi;
            
            import java.io.File;
            import java.util.*;
            
            public class DocsApiExample {
            
                public static void main(String[] args) {
                    ApiClient defaultClient = Configuration.getDefaultApiClient();
                    
                    // Configure HTTP basic authorization: basic
                    HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
                    basic.setUsername("YOUR USERNAME");
                    basic.setPassword("YOUR PASSWORD");
                    
                    // Configure API key authorization: jwt
                    ApiKeyAuth jwt = (ApiKeyAuth) defaultClient.getAuthentication("jwt");
                    jwt.setApiKey("YOUR API KEY");
                    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
                    //jwt.setApiKeyPrefix("Token");
                    
                    
            
                    DocsApi apiInstance = new DocsApi();
                    
                    array[Document] body = ; // array[Document] | 
                    
                    try {
                        array[Document] result = apiInstance.guessDocs(body);
                        System.out.println(result);
                    } catch (ApiException e) {
                        System.err.println("Exception when calling DocsApi#guessDocs");
                        e.printStackTrace();
                    }
                }
            }
import io.swagger.client.api.DocsApi;
            
            public class DocsApiExample {
            
                public static void main(String[] args) {
                    DocsApi apiInstance = new DocsApi();
                    
                    array[Document] body = ; // array[Document] | 
                    
                    try {
                        array[Document] result = apiInstance.guessDocs(body);
                        System.out.println(result);
                    } catch (ApiException e) {
                        System.err.println("Exception when calling DocsApi#guessDocs");
                        e.printStackTrace();
                    }
                }
            }

            Configuration *apiConfig = [Configuration sharedConfig];
            // Configure HTTP basic authorization (authentication scheme: basic)
            [apiConfig setUsername:@"YOUR_USERNAME"];
            [apiConfig setPassword:@"YOUR_PASSWORD"];
            
            // Configure API key authorization: (authentication scheme: jwt)
            [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
            
            
            array[Document] *body = ; // 
            
            
            DocsApi *apiInstance = [[DocsApi alloc] init];
            
            // Try to parse the documents based on the few data provided
            [apiInstance guessDocsWithCompletionHandler: :body
                          ^(array[Document] output, NSError* error) {
            
                                        if (output) {
                                            NSLog(@"%@", output);
                                        }
            
                                        if (error) {
                                            NSLog(@"Error: %@", error);
                                        }
                                    }];
            
var SecuriboxPxApi = require('securibox_px_api');
            
            var defaultClient = SecuriboxPxApi.ApiClient.instance;
            
            // Configure HTTP basic authorization: basic
            var basic = defaultClient.authentications['basic'];
            basic.username = 'YOUR USERNAME'
            basic.password = 'YOUR PASSWORD'
            
            // Configure API key authorization: jwt
            var jwt = defaultClient.authentications['jwt'];
            jwt.apiKey = "YOUR API KEY"
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //jwt.apiKeyPrefix['Authorization'] = "Token"
            
            
            
            var api = new SecuriboxPxApi.DocsApi()
            
            var callback = function(error, data, response) {
              if (error) {
                console.error(error);
              } else {
                console.log('API called successfully. Returned data: ' + data);
              }
            };
            api.guessDocs(bodycallback);
            
            
using System;
            using System.Diagnostics;
            using IO.Swagger.Api;
            using IO.Swagger.Client;
            using IO.Swagger.Model;
            
            namespace Example
            {
                public class guessDocsExample
                {
                    public void main()
                    {
                        
                        // Configure HTTP basic authorization: basic
                        Configuration.Default.Username = "YOUR_USERNAME";
                        Configuration.Default.Password = "YOUR_PASSWORD";
                        // Configure API key authorization: jwt
                        Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                        // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                        // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
                        
            
                        var apiInstance = new DocsApi();
                        
                        
                        
                        var body = new array[Document](); // array[Document] | 
                        
                        
            
                        try
                        {
                            
                            // Try to parse the documents based on the few data provided
                            
                            array[Document] result = apiInstance.guessDocs(body);
                            Debug.WriteLine(result);
                        }
                        catch (Exception e)
                        {
                            Debug.Print("Exception when calling DocsApi.guessDocs: " + e.Message );
                        }
                    }
                }
            }
            
<?php
            require_once(__DIR__ . '/vendor/autoload.php');
            
            // Configure HTTP basic authorization: basic
            Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
            Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');
            // Configure API key authorization: jwt
            Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');
            
            
            $api_instance = new Swagger\Client\Api{{classname}}();
            $body = ; // array[Document] | 
            
            
            try {
                $result = $api_instance->guessDocs($body);
                print_r($result);
            } catch (Exception $e) {
                echo 'Exception when calling DocsApi->guessDocs: ', $e->getMessage(), PHP_EOL;
            }
            ?>
use Data::Dumper;
            use WWW::SwaggerClient::Configuration;
            use WWW::SwaggerClient::DocsApi;
            
            # Configure HTTP basic authorization: basic
            $WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
            $WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';
            # Configure API key authorization: jwt
            $WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
            # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            #$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";
            
            
            my $api_instance = WWW::SwaggerClient::DocsApi->new();
            my $body = [WWW::SwaggerClient::Object::array[Document]->new()]; # array[Document] | 
            
            
            eval { 
                my $result = $api_instance->guessDocs(body => $body);
                print Dumper($result);
            };
            if ($@) {
                warn "Exception when calling DocsApi->guessDocs: $@\n";
            }
from __future__ import print_statement
            import time
            import swagger_client
            from swagger_client.rest import ApiException
            from pprint import pprint
            
            # Configure HTTP basic authorization: basic
            swagger_client.configuration.username = 'YOUR_USERNAME'
            swagger_client.configuration.password = 'YOUR_PASSWORD'
            # Configure API key authorization: jwt
            swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
            # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            # swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'
            
            
            # create an instance of the API class
            api_instance = swagger_client.DocsApi()
            body =  # array[Document] | 
            
            
            try: 
                # Try to parse the documents based on the few data provided
                api_response = api_instance.guess_docs(body)
                pprint(api_response)
            except ApiException as e:
                print("Exception when calling DocsApi->guessDocs: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Parsed documents. Note that the parsing may be uncomplete (need user validation). Any error will be listed in the *Document.processingErrors* property.

Status: 400 - Bad request. Missing or invalid parameters.


parseDocs

Parse the provided documents

If *Document.labelId* is not provided, returns the document with *Document.ExtractedData* parsed according to the most probable label. Otherwise, it parses the document according to the specified *Document.labelId* and *Document.detailedLabelId*. If *mode='split'*, it accepts an **array** containing only a single document, which content will be split by page.


/docs/parse

Usage and SDK Samples

curl -X POST -H "Authorization: Basic [[basicHash]]" -H "Authorization: [[apiKey]]" "https://parse.securibox.eu/api/v1/docs/parse?mode="
import io.swagger.client.*;
            import io.swagger.client.auth.*;
            import io.swagger.client.model.*;
            import io.swagger.client.api.DocsApi;
            
            import java.io.File;
            import java.util.*;
            
            public class DocsApiExample {
            
                public static void main(String[] args) {
                    ApiClient defaultClient = Configuration.getDefaultApiClient();
                    
                    // Configure HTTP basic authorization: basic
                    HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
                    basic.setUsername("YOUR USERNAME");
                    basic.setPassword("YOUR PASSWORD");
                    
                    // Configure API key authorization: jwt
                    ApiKeyAuth jwt = (ApiKeyAuth) defaultClient.getAuthentication("jwt");
                    jwt.setApiKey("YOUR API KEY");
                    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
                    //jwt.setApiKeyPrefix("Token");
                    
                    
            
                    DocsApi apiInstance = new DocsApi();
                    
                    array[Document] body = ; // array[Document] | 
                    
                    String mode = mode_example; // String | Special handling parameter. If provided, it must be equal to 'split'.
                    
                    try {
                        array[Document] result = apiInstance.parseDocs(body, mode);
                        System.out.println(result);
                    } catch (ApiException e) {
                        System.err.println("Exception when calling DocsApi#parseDocs");
                        e.printStackTrace();
                    }
                }
            }
import io.swagger.client.api.DocsApi;
            
            public class DocsApiExample {
            
                public static void main(String[] args) {
                    DocsApi apiInstance = new DocsApi();
                    
                    array[Document] body = ; // array[Document] | 
                    
                    String mode = mode_example; // String | Special handling parameter. If provided, it must be equal to 'split'.
                    
                    try {
                        array[Document] result = apiInstance.parseDocs(body, mode);
                        System.out.println(result);
                    } catch (ApiException e) {
                        System.err.println("Exception when calling DocsApi#parseDocs");
                        e.printStackTrace();
                    }
                }
            }

            Configuration *apiConfig = [Configuration sharedConfig];
            // Configure HTTP basic authorization (authentication scheme: basic)
            [apiConfig setUsername:@"YOUR_USERNAME"];
            [apiConfig setPassword:@"YOUR_PASSWORD"];
            
            // Configure API key authorization: (authentication scheme: jwt)
            [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
            
            
            array[Document] *body = ; // 
            String *mode = mode_example; // Special handling parameter. If provided, it must be equal to 'split'. (optional)
            
            
            DocsApi *apiInstance = [[DocsApi alloc] init];
            
            // Parse the provided documents
            [apiInstance parseDocsWithCompletionHandler: :body
                mode:mode
                          ^(array[Document] output, NSError* error) {
            
                                        if (output) {
                                            NSLog(@"%@", output);
                                        }
            
                                        if (error) {
                                            NSLog(@"Error: %@", error);
                                        }
                                    }];
            
var SecuriboxPxApi = require('securibox_px_api');
            
            var defaultClient = SecuriboxPxApi.ApiClient.instance;
            
            // Configure HTTP basic authorization: basic
            var basic = defaultClient.authentications['basic'];
            basic.username = 'YOUR USERNAME'
            basic.password = 'YOUR PASSWORD'
            
            // Configure API key authorization: jwt
            var jwt = defaultClient.authentications['jwt'];
            jwt.apiKey = "YOUR API KEY"
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //jwt.apiKeyPrefix['Authorization'] = "Token"
            
            
            
            var api = new SecuriboxPxApi.DocsApi()
            
            var callback = function(error, data, response) {
              if (error) {
                console.error(error);
              } else {
                console.log('API called successfully. Returned data: ' + data);
              }
            };
            api.parseDocs(bodycallback);
            
            
using System;
            using System.Diagnostics;
            using IO.Swagger.Api;
            using IO.Swagger.Client;
            using IO.Swagger.Model;
            
            namespace Example
            {
                public class parseDocsExample
                {
                    public void main()
                    {
                        
                        // Configure HTTP basic authorization: basic
                        Configuration.Default.Username = "YOUR_USERNAME";
                        Configuration.Default.Password = "YOUR_PASSWORD";
                        // Configure API key authorization: jwt
                        Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                        // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                        // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
                        
            
                        var apiInstance = new DocsApi();
                        
                        
                        
                        var body = new array[Document](); // array[Document] | 
                        
                        
                        
                        var mode = mode_example;  // String | Special handling parameter. If provided, it must be equal to 'split'. (optional) 
                        
                        
                        
            
                        try
                        {
                            
                            // Parse the provided documents
                            
                            array[Document] result = apiInstance.parseDocs(body, mode);
                            Debug.WriteLine(result);
                        }
                        catch (Exception e)
                        {
                            Debug.Print("Exception when calling DocsApi.parseDocs: " + e.Message );
                        }
                    }
                }
            }
            
<?php
            require_once(__DIR__ . '/vendor/autoload.php');
            
            // Configure HTTP basic authorization: basic
            Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
            Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');
            // Configure API key authorization: jwt
            Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');
            
            
            $api_instance = new Swagger\Client\Api{{classname}}();
            $body = ; // array[Document] | 
            $mode = mode_example; // String | Special handling parameter. If provided, it must be equal to 'split'.
            
            
            try {
                $result = $api_instance->parseDocs($body, $mode);
                print_r($result);
            } catch (Exception $e) {
                echo 'Exception when calling DocsApi->parseDocs: ', $e->getMessage(), PHP_EOL;
            }
            ?>
use Data::Dumper;
            use WWW::SwaggerClient::Configuration;
            use WWW::SwaggerClient::DocsApi;
            
            # Configure HTTP basic authorization: basic
            $WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
            $WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';
            # Configure API key authorization: jwt
            $WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
            # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            #$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";
            
            
            my $api_instance = WWW::SwaggerClient::DocsApi->new();
            my $body = [WWW::SwaggerClient::Object::array[Document]->new()]; # array[Document] | 
            my $mode = [mode_example]; # String | Special handling parameter. If provided, it must be equal to 'split'.
            
            
            eval { 
                my $result = $api_instance->parseDocs(body => $body, mode => $mode);
                print Dumper($result);
            };
            if ($@) {
                warn "Exception when calling DocsApi->parseDocs: $@\n";
            }
from __future__ import print_statement
            import time
            import swagger_client
            from swagger_client.rest import ApiException
            from pprint import pprint
            
            # Configure HTTP basic authorization: basic
            swagger_client.configuration.username = 'YOUR_USERNAME'
            swagger_client.configuration.password = 'YOUR_PASSWORD'
            # Configure API key authorization: jwt
            swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
            # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            # swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'
            
            
            # create an instance of the API class
            api_instance = swagger_client.DocsApi()
            body =  # array[Document] | 
            mode = mode_example # String | Special handling parameter. If provided, it must be equal to 'split'. (optional)
            
            
            try: 
                # Parse the provided documents
                api_response = api_instance.parse_docs(body, mode=mode)
                pprint(api_response)
            except ApiException as e:
                print("Exception when calling DocsApi->parseDocs: %s\n" % e)

Parameters

Body parameters
Name Description
body *
Query parameters
Name Description
mode
String
Special handling parameter. If provided, it must be equal to 'split'.

Responses

Status: 200 - Classified and parsed documents. Any error will be listed in the *Document.processingErrors* property

Status: 400 - Bad request. Missing or invalid parameters.


trainDocs

Store the provided documents for model training

Store documents which are properly classified and parsed for further training. To be used to feed new or wrongly processed data back into the application.


/docs/train

Usage and SDK Samples

curl -X POST -H "Authorization: Basic [[basicHash]]" -H "Authorization: [[apiKey]]" "https://parse.securibox.eu/api/v1/docs/train"
import io.swagger.client.*;
            import io.swagger.client.auth.*;
            import io.swagger.client.model.*;
            import io.swagger.client.api.DocsApi;
            
            import java.io.File;
            import java.util.*;
            
            public class DocsApiExample {
            
                public static void main(String[] args) {
                    ApiClient defaultClient = Configuration.getDefaultApiClient();
                    
                    // Configure HTTP basic authorization: basic
                    HttpBasicAuth basic = (HttpBasicAuth) defaultClient.getAuthentication("basic");
                    basic.setUsername("YOUR USERNAME");
                    basic.setPassword("YOUR PASSWORD");
                    
                    // Configure API key authorization: jwt
                    ApiKeyAuth jwt = (ApiKeyAuth) defaultClient.getAuthentication("jwt");
                    jwt.setApiKey("YOUR API KEY");
                    // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
                    //jwt.setApiKeyPrefix("Token");
                    
                    
            
                    DocsApi apiInstance = new DocsApi();
                    
                    array[Document] body = ; // array[Document] | 
                    
                    try {
                        array[Document] result = apiInstance.trainDocs(body);
                        System.out.println(result);
                    } catch (ApiException e) {
                        System.err.println("Exception when calling DocsApi#trainDocs");
                        e.printStackTrace();
                    }
                }
            }
import io.swagger.client.api.DocsApi;
            
            public class DocsApiExample {
            
                public static void main(String[] args) {
                    DocsApi apiInstance = new DocsApi();
                    
                    array[Document] body = ; // array[Document] | 
                    
                    try {
                        array[Document] result = apiInstance.trainDocs(body);
                        System.out.println(result);
                    } catch (ApiException e) {
                        System.err.println("Exception when calling DocsApi#trainDocs");
                        e.printStackTrace();
                    }
                }
            }

            Configuration *apiConfig = [Configuration sharedConfig];
            // Configure HTTP basic authorization (authentication scheme: basic)
            [apiConfig setUsername:@"YOUR_USERNAME"];
            [apiConfig setPassword:@"YOUR_PASSWORD"];
            
            // Configure API key authorization: (authentication scheme: jwt)
            [apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            //[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];
            
            
            array[Document] *body = ; // 
            
            
            DocsApi *apiInstance = [[DocsApi alloc] init];
            
            // Store the provided documents for model training
            [apiInstance trainDocsWithCompletionHandler: :body
                          ^(array[Document] output, NSError* error) {
            
                                        if (output) {
                                            NSLog(@"%@", output);
                                        }
            
                                        if (error) {
                                            NSLog(@"Error: %@", error);
                                        }
                                    }];
            
var SecuriboxPxApi = require('securibox_px_api');
            
            var defaultClient = SecuriboxPxApi.ApiClient.instance;
            
            // Configure HTTP basic authorization: basic
            var basic = defaultClient.authentications['basic'];
            basic.username = 'YOUR USERNAME'
            basic.password = 'YOUR PASSWORD'
            
            // Configure API key authorization: jwt
            var jwt = defaultClient.authentications['jwt'];
            jwt.apiKey = "YOUR API KEY"
            // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
            //jwt.apiKeyPrefix['Authorization'] = "Token"
            
            
            
            var api = new SecuriboxPxApi.DocsApi()
            
            var callback = function(error, data, response) {
              if (error) {
                console.error(error);
              } else {
                console.log('API called successfully. Returned data: ' + data);
              }
            };
            api.trainDocs(bodycallback);
            
            
using System;
            using System.Diagnostics;
            using IO.Swagger.Api;
            using IO.Swagger.Client;
            using IO.Swagger.Model;
            
            namespace Example
            {
                public class trainDocsExample
                {
                    public void main()
                    {
                        
                        // Configure HTTP basic authorization: basic
                        Configuration.Default.Username = "YOUR_USERNAME";
                        Configuration.Default.Password = "YOUR_PASSWORD";
                        // Configure API key authorization: jwt
                        Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
                        // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
                        // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
                        
            
                        var apiInstance = new DocsApi();
                        
                        
                        
                        var body = new array[Document](); // array[Document] | 
                        
                        
            
                        try
                        {
                            
                            // Store the provided documents for model training
                            
                            array[Document] result = apiInstance.trainDocs(body);
                            Debug.WriteLine(result);
                        }
                        catch (Exception e)
                        {
                            Debug.Print("Exception when calling DocsApi.trainDocs: " + e.Message );
                        }
                    }
                }
            }
            
<?php
            require_once(__DIR__ . '/vendor/autoload.php');
            
            // Configure HTTP basic authorization: basic
            Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
            Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');
            // Configure API key authorization: jwt
            Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');
            
            
            $api_instance = new Swagger\Client\Api{{classname}}();
            $body = ; // array[Document] | 
            
            
            try {
                $result = $api_instance->trainDocs($body);
                print_r($result);
            } catch (Exception $e) {
                echo 'Exception when calling DocsApi->trainDocs: ', $e->getMessage(), PHP_EOL;
            }
            ?>
use Data::Dumper;
            use WWW::SwaggerClient::Configuration;
            use WWW::SwaggerClient::DocsApi;
            
            # Configure HTTP basic authorization: basic
            $WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
            $WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';
            # Configure API key authorization: jwt
            $WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
            # uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            #$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";
            
            
            my $api_instance = WWW::SwaggerClient::DocsApi->new();
            my $body = [WWW::SwaggerClient::Object::array[Document]->new()]; # array[Document] | 
            
            
            eval { 
                my $result = $api_instance->trainDocs(body => $body);
                print Dumper($result);
            };
            if ($@) {
                warn "Exception when calling DocsApi->trainDocs: $@\n";
            }
from __future__ import print_statement
            import time
            import swagger_client
            from swagger_client.rest import ApiException
            from pprint import pprint
            
            # Configure HTTP basic authorization: basic
            swagger_client.configuration.username = 'YOUR_USERNAME'
            swagger_client.configuration.password = 'YOUR_PASSWORD'
            # Configure API key authorization: jwt
            swagger_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
            # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            # swagger_client.configuration.api_key_prefix['Authorization'] = 'Bearer'
            
            
            # create an instance of the API class
            api_instance = swagger_client.DocsApi()
            body =  # array[Document] | 
            
            
            try: 
                # Store the provided documents for model training
                api_response = api_instance.train_docs(body)
                pprint(api_response)
            except ApiException as e:
                print("Exception when calling DocsApi->trainDocs: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Array of documents. Documents with errors are NOT stored. Any error will be listed in the *Document.processingErrors* property.

Status: 400 - Bad request. Missing or invalid parameters.