` |
## Responses
{% tabs %}
{% tab title="200" %}
```json
{
"status": "ok",
"credits": 50 // pages
}
```
{% endtab %}
{% endtabs %}
# Extraction Details
# Supported Languages
Extracta LABS is dedicated to breaking language barriers in document extraction, offering robust support for a diverse range of languages. Our advanced AI algorithms are designed to accurately parse and extract information from documents in multiple languages, ensuring that businesses worldwide can leverage our technology.
## Language Parameter
When creating an extraction request, specify the language of your document using the `language` parameter in the extraction details. This helps tailor the extraction process to the linguistic nuances of the content, enhancing accuracy and efficiency.
```json
{
"extractionDetails": {
"language": "Multi-Lingual"
}
}
```
## Currently Supported Languages
Below is a list of languages currently supported by Extracta LABS. Use the corresponding string when specifying the language in your extraction requests.
Arabic, Bangla, Bulgarian, Croatian, Czech, English, Filipino, French, German, Hindi, Hungarian, Italian, Nepali, Polish, Portuguese, Romanian, Russian, Serbian, Spanish, Turkish, Ukrainian, Urdu, and Vietnamese.
#### We are also excited to announce the addition of **'Multi-Lingual'** support. This new feature allows for the processing of documents in any language, ensuring that Extracta LABS can handle your documents regardless of the language used. This enhancement makes our platform even more versatile and accommodating to diverse linguistic needs.
Language Arabic German Russian Bangla Hindi Serbian Bulgarian Hungarian Spanish Croatian Italian Turkish Czech Nepali Ukrainian English Polish Urdu Filipino Portuguese Vietnamese French Romanian Multi-Lingual
{% content-ref url="/pages/Kr8TtNYErc3zJQQ68V7K" %}
[1. Create extraction](/data-extraction-api/api-endpoints-data-extraction/1.-create-extraction)
{% endcontent-ref %}
# Options
The `options` object in Extracta's API requests provides additional customization for your data extraction process. By setting different properties within this object, you can tailor the extraction to suit the specific needs of your documents. Here's how each option affects your data extraction:
## Options Overview
### `hasTable`
* **Type**: Boolean
* **Not required**
* **Default**: `false`
* **Description**: Indicates whether the document to be processed contains tables. When set to `true`, the extraction process includes an additional step specifically designed to analyze and extract information from tables within the document. This option ensures that table data is accurately recognized and extracted, providing structured information that's easy to use and analyze.
### `hasVisuals`
* **Type**: Boolean
* **Not required**
* **Default**: `false`
* **Description**: Indicates whether the document contains visual elements such as charts, graphs and diagrams that need to be processed. When set to true, the extraction process includes an additional step designed to detect, analyze and extract structured data from these visual components.
### `handwrittenTextRecognition`
* **Type**: Boolean
* **Not required**
* **Default**: `false`
* **Description**: Determines if the document includes handwritten text that needs to be recognized and extracted. Setting this option to `true` initiates a specialized step in the extraction process focused on analyzing handwritten text. This feature leverages advanced OCR and machine learning techniques to convert handwritten notes into digital text, enhancing the comprehensiveness of the data extraction.
### `checkboxRecognition`
* **Type**: Boolean
* **Not required**
* **Default**: `false`
* **Description**: Determines if the document contains checkboxes that need to be recognized and their states (checked or unchecked) extracted. When set to true, the extraction process includes a specialized step focused on identifying checkboxes within the document and accurately determining their status.
### `longDocument`
* **Type**: Boolean
* **Not required**
* **Default**: `false`
* **Description**: Designed for handling very large or complex documents that may exceed typical processing limits. When set to true, the extraction process applies optimized methods to ensure stability and accuracy across long documents, reducing the chance of timeouts or incomplete results. This option is particularly useful for reports, research papers, legal contracts, or any file with extensive text content.
### `splitPdfPages`
* **Type**: Boolean
* **Not required**
* **Default**: `false`
* **Description**: Controls whether a PDF is split into individual pages before processing. When set to true, each page is treated as a separate extraction unit, improving performance and accuracy for multi-page PDFs. This option is ideal when you need fine-grained control over page-level data or want to parallelize processing for faster results. Think of a document with 100 pages full of one-page invoices, in this case you want to extract data for every page, so set the parameter to true.
### `specificPageProcessing`
* **Type**: Boolean
* **Not required**
* **Default**: `false`
* **Description**: Specific Page Processing is a feature designed to allow users to extract and process only a specified range of pages from a PDF document rather than processing the entire document. This feature is particularly useful when working with large PDF files where only certain sections or pages are relevant for the task at hand.
### `specificPageProcessingOptions`
* **Type**: Map
* **Required only if** `specificPageProcessing` **is** `true`
* **Description**: When **Specific Page Processing** is enabled, the system allows the user to define a range of pages (using `from` and `to` parameters) that they want to focus on. The specified range of pages is then extracted from the original PDF, creating a new document that contains only those pages. This newly created PDF is treated as a separate file and is processed according to the usual workflow—whether for storage, analysis, or further manipulation.
* **Example:** Imagine a scenario where you have a 100-page PDF document, but the relevant information that you want to extract is from page 1 to 3. This feature allows you to specify this range, reducing processing time and cost.
{
"options": {
"specificPageProcessing": true,
"specificPageProcessingOptions": {
"from": 1,
"to": 3
}
}
}
{
"options": {
"hasTable": false,
"handwrittenTextRecognition": false,
"checkboxRecognition": false
}
}
.
```
This makes the system **modular and scalable**, allowing multiple features (e.g., data extraction, document classification, etc.) to have their own distinct set of events without overlap.
***
## 🔍 Current Feature: `extraction`
All current webhook events are prefixed with `extraction.` because they relate to **data extraction**, which is the first core feature of Extracta LABS.
***
## ✅ Available `extraction` Events
### **`extraction.processed`**
**Description:**\
Triggered when one or more files are successfully processed and data has been extracted. If you process multiple files in a single upload, this webhook will be triggered when all the files are processed.
**Why it's useful:**\
Initiate follow-up actions like storing results, analyzing data, or notifying stakeholders.
***
### **`extraction.edited`**
**Description:**\
Fired when a user manually edits the extracted data in the Extracta LABS interface.
**Why it's useful:**\
Track user input, sync updates to downstream systems, or trigger quality checks.
***
### **`extraction.confirmed`**
**Description:**\
Occurs when a user manually confirms the extracted data, indicating final approval.
**Why it's useful:**\
Use this as a signal to finalize workflows, store results permanently, or notify teams.
***
### **`extraction.failed`**
**Description:**\
Sent when a file fails to process (e.g. due to corruption, unsupported format, or internal errors).
**Why it's useful:**\
Alert your team, retry processing, or prompt the user to upload a new version.
***
## 🧠 Future-Proofing: Other Feature Namespaces
As Extracta LABS grows, additional webhook namespaces will be introduced. For example:
**`classification.*` (future)**
***
By using namespaced events like `extraction.processed`, your application can easily distinguish between different types of events and scale accordingly as new features are added.
# Postman Integration
* **Set Up Your Environment:**
* Configure your variables in **Collection -> Variables** to include your **API key**.
* How to make an API Key: [Authentication](/api-reference/authentication)
* **Import the file in Postman as in the screenshot below:**
`POST` `/documentClassification/createClassification`
Initiates a new document classification process. This endpoint allows you to define a classification with a list of possible document types. Once created, you can use the returned `classificationId` to upload documents for type prediction.
## Server URL
```
https://api.extracta.ai/api/v1
```
## Headers
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
## Body
Name Type Required Description namestring trueA name for the classification. descriptionstring falseA description for the classification. documentTypesobject trueAn array of objects, each specifying a document type.
## 💡 Need help defining `documentTypes`?
Each item in the `documentTypes` array represents a document category used for classification (e.g., Invoice, Receipt). To learn how to properly define a document type — including required fields, keyword strategy, and optional data extraction linkage — refer to the [Document Types](/document-classification-api/classification-details/document-types) page.
## Body Example
```json
{
"classificationDetails": {
"name": "Financial Document Classifier",
"description": "Classifies uploaded documents into predefined financial document types.",
"documentTypes": [
{
"name": "Invoice",
"description": "Standard commercial invoice from vendors or suppliers.",
"uniqueWords": ["invoice number", "bill to", "total amount"],
"extractionId": "invoiceExtractionId"
},
{
"name": "Purchase Order",
"description": "Internal or external purchase order documents.",
"uniqueWords": ["PO number", "item description", "quantity ordered"]
},
{
"name": "Receipt",
"description": "Retail or online transaction receipts.",
"uniqueWords": ["receipt", "paid", "transaction id"]
}
]
}
}
```
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
async function createClassification(token, classificationDetails) {
const url = "https://api.extracta.ai/api/v1/documentClassification/createClassification";
try {
const response = await axios.post(url, {
classificationDetails: classificationDetails
}, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
return response.data;
} catch (error) {
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const classificationDetails = {
name: "Financial Documents Classifier",
description: "Classifies invoices, receipts, and purchase orders.",
documentTypes: [
{
name: "Invoice",
description: "Documents with billing and totals for payment.",
uniqueWords: ["invoice number", "bill to", "total amount"],
extractionId: "invoiceExtractionId"
},
{
name: "Receipt",
description: "Confirmation of payment or transaction.",
uniqueWords: ["receipt", "paid", "transaction id"]
},
{
name: "Purchase Order",
description: "Authorizes a purchase transaction.",
uniqueWords: ["PO number", "item", "quantity ordered"]
}
]
};
try {
const response = await createClassification(token, classificationDetails);
console.log("New Classification Created:", response);
} catch (error) {
console.error("Failed to create classification:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def create_classification(token, classification_details):
url = "https://api.extracta.ai/api/v1/documentClassification/createClassification"
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
try:
response = requests.post(url, json={"classificationDetails": classification_details}, headers=headers)
response.raise_for_status()
return response.json()
except requests.RequestException as e:
print(e)
return None
if __name__ == "__main__":
token = "apiKey"
classification_details = {
"name": "Financial Documents Classifier",
"description": "Classifies invoices, receipts, and purchase orders.",
"documentTypes": [
{
"name": "Invoice",
"description": "Documents with billing and totals for payment.",
"uniqueWords": ["invoice number", "bill to", "total amount"],
"extractionId": "invoiceExtractionId"
},
{
"name": "Receipt",
"description": "Confirmation of payment or transaction.",
"uniqueWords": ["receipt", "paid", "transaction id"]
},
{
"name": "Purchase Order",
"description": "Authorizes a purchase transaction.",
"uniqueWords": ["PO number", "item", "quantity ordered"]
}
]
}
response = create_classification(token, classification_details)
print("New Classification Created:", response)
```
{% endtab %}
{% tab title="PHP" %}
```php
$classificationDetails]);
// Set cURL options
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json',
'Authorization: Bearer ' . $token,
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, 1);
try {
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Curl error: ' . curl_error($ch));
}
return $response;
} catch (Exception $e) {
return 'Error: ' . $e->getMessage();
} finally {
curl_close($ch);
}
}
// Example usage
$token = 'apiKey';
$classificationDetails = [
"name" => "Financial Documents Classifier",
"description" => "Classifies invoices, receipts, and purchase orders.",
"documentTypes" => [
[
"name" => "Invoice",
"description" => "Documents with billing and totals for payment.",
"uniqueWords" => ["invoice number", "bill to", "total amount"],
"extractionId" => "invoiceExtractionId"
],
[
"name" => "Receipt",
"description" => "Confirmation of payment or transaction.",
"uniqueWords" => ["receipt", "paid", "transaction id"]
],
[
"name" => "Purchase Order",
"description" => "Authorizes a purchase transaction.",
"uniqueWords" => ["PO number", "item", "quantity ordered"]
]
]
];
try {
$response = createClassification($token, $classificationDetails);
echo $response;
} catch (Exception $e) {
echo "Failed to create new classification: " . $e->getMessage();
}
?>
```
{% endtab %}
{% endtabs %}
## Responses
{% tabs %}
{% tab title="200" %}
```json
{
"status": "created",
"createdAt": 1712547789609,
"classificationId": "classificationId"
}
```
{% endtab %}
{% tab title="400" %}
```json
{
"status": "error",
"message": "Name is required"
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"status": "error",
"message": "Error creating classification"
}
```
{% endtab %}
{% endtabs %}
# 2. View classification
`POST` `/documentClassification/viewClassification`
This endpoint retrieves the details of a classification process previously defined in the system. By submitting the unique classificationId, you can obtain information such as the classification name, description, configured document types, associated keywords, and any linked extraction templates. This is useful for verifying your classification setup or for debugging and auditing purposes.
## Server URL
```
https://api.extracta.ai/api/v1
```
## Headers
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
## Body
Name Type Required Description classificationIdstring trueUnique identifier for the classification.
## Body Example
```json
{
"classificationId": "classificationId"
}
```
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
async function viewClassification(token, classificationId) {
const url = "https://api.extracta.ai/api/v1/documentClassification/viewClassification";
try {
const response = await axios.post(url, {
classificationId: classificationId
}, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
return response.data;
} catch (error) {
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const classificationId = 'classificationId';
try {
const classificationDetails = await viewClassification(token, classificationId);
console.log("Classification Details:", classificationDetails);
} catch (error) {
console.error("Failed to retrieve classification details:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def view_classification(token, classification_id):
url = "https://api.extracta.ai/api/v1/documentClassification/viewClassification"
headers = {
'Content-Type': 'application/json',
'Authorization': f'Bearer {token}'
}
payload = {
'classificationId': classification_id
}
try:
response = requests.post(url, json=payload, headers=headers)
response.raise_for_status()
return response.json()
except requests.RequestException as e:
print(f"Failed to retrieve classification details: {e}")
return None
# Example usage
if __name__ == "__main__":
token = 'apiKey'
classification_id = 'classificationId'
classification_details = view_classification(token, classification_id)
if classification_details is not None:
print("Classification Details:", classification_details)
```
{% endtab %}
{% tab title="PHP" %}
```php
$classificationId]);
// Set cURL options
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json',
'Authorization: Bearer ' . $token
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, 1);
try {
// Execute cURL session
$response = curl_exec($ch);
// Check for cURL errors
if (curl_errno($ch)) {
throw new Exception('Curl error: ' . curl_error($ch));
}
// return the response as an associative array
return json_decode($response, true);
} catch (Exception $e) {
return 'Error: ' . $e->getMessage();
} finally {
curl_close($ch);
}
}
// Example usage
$token = 'apiKey';
$classificationId = 'classificationId';
try {
$classificationDetails = viewClassification($token, $classificationId);
print_r($classificationDetails);
} catch (Exception $e) {
echo "Failed to retrieve classification details: " . $e->getMessage();
}
?>
```
{% endtab %}
{% endtabs %}
## Responses
{% tabs %}
{% tab title="200" %}
```json
{
"status": "success",
"classificationId": "-OPkce8E1CuEQeHDZetx",
"classificationDetails": {
"createdAt": 1746720170530,
"name": "Financial Document Classifier"
"description": "Classifies uploaded documents into predefined financial document types.",
"documentTypes": [
{
"description": "Standard commercial invoice from vendors or suppliers.",
"extractionId": "-OPXR1F82I0cRYJPcHNo",
"name": "Invoice",
"uniqueWords": [
"invoice number",
"bill to",
"total amount"
]
},
{
"description": "Internal or external purchase order documents.",
"name": "Purchase Order",
"uniqueWords": [
"PO number",
"item description",
"quantity ordered"
]
},
{
"description": "Retail or online transaction receipts.",
"name": "Receipt",
"uniqueWords": [
"receipt",
"paid",
"transaction id"
]
}
]
}
}
```
{% endtab %}
{% tab title="400" %}
```json
{
"status": "error",
"message": "Classification does not exist"
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"status": "error",
"message": "Error viewing classification"
}
```
{% endtab %}
{% endtabs %}
# 3. Update classification
`PATCH` `/documentClassification/updateClassification`
Updates an existing document classification process by modifying specific parameters within the classification details. This endpoint is useful for adjusting document types, keywords, or metadata without recreating the entire classification setup.
## Server URL
```
https://api.extracta.ai/api/v1
```
## Headers
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
## Body
Name Type Required Description classificationIdstring trueUnique identifier for the classification. namestring trueA name for the classification. descriptionstring trueA description for the classification. documentTypeslist<object> trueAn array of objects, each specifying a document type.
## Body Example
```json
{
"classificationId": "classificationId",
"classificationDetails": {
"name": "Financial Document Classifier - updated",
"description": "Classifies uploaded documents into predefined financial document types. - updated",
"documentTypes": [
{
"name": "Invoice",
"description": "Standard commercial invoice from vendors or suppliers.",
"uniqueWords": [
"invoice number",
"bill to",
"total amount"
],
"extractionId": "-OPXR1F82I0cRYJPcHNo"
}
]
}
}
```
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
async function updateClassification(token, classificationId, classificationDetails) {
const url = "https://api.extracta.ai/api/v1/documentClassification/updateClassification";
try {
const response = await axios.patch(url, {
classificationId,
classificationDetails
}, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
return response.data;
} catch (error) {
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const classificationId = 'classificationId';
const classificationDetails = {
"name": "Financial Document Classifier - updated",
"description": "Classifies uploaded documents into predefined financial document types. - updated",
"documentTypes": [
{
"name": "Invoice",
"description": "Standard commercial invoice from vendors or suppliers.",
"uniqueWords": [
"invoice number",
"bill to",
"total amount"
],
"extractionId": "-OPXR1F82I0cRYJPcHNo"
}
]
};
try {
const response = await updateClassification(token, classificationId, classificationDetails);
console.log("Classification Updated:", response);
} catch (error) {
console.error("Failed to update classification:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def update_classification(token, classification_id, classification_details):
url = "https://api.extracta.ai/api/v1/documentClassification/updateClassification"
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
payload = {
"classificationId": classification_id,
"classificationDetails": classification_details
}
try:
response = requests.patch(url, json=payload, headers=headers)
response.raise_for_status()
return response.json()
except requests.RequestException as e:
print(f"Failed to update classification: {e}")
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
classification_id = "classificationId"
classification_details = {
"name": "Financial Document Classifier - updated",
"description": "Classifies uploaded documents into predefined financial document types. - updated",
"documentTypes": [
{
"name": "Invoice",
"description": "Standard commercial invoice from vendors or suppliers.",
"uniqueWords": [
"invoice number",
"bill to",
"total amount"
],
"extractionId": "-OPXR1F82I0cRYJPcHNo"
}
]
}
response = update_classification(token, classification_id, classification_details)
print("Classification Updated:", response)
```
{% endtab %}
{% tab title="PHP" %}
```php
$classificationId,
'classificationDetails' => $classificationDetails
]);
// Set cURL options
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PATCH');
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json',
'Authorization: Bearer ' . $token,
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
try {
// Execute cURL session
$response = curl_exec($ch);
// Check for cURL errors
if (curl_errno($ch)) {
throw new Exception('Curl error: ' . curl_error($ch));
}
return $response;
} catch (Exception $e) {
return 'Error: ' . $e->getMessage();
} finally {
curl_close($ch);
}
}
// Example usage
$token = 'apiKey';
$classificationId = 'classificationId';
$classificationDetails = [
"name" => "Updated Financial Classifier",
"description" => "Updated description for the financial document classifier.",
"documentTypes" => [
[
"name" => "Invoice",
"description" => "Updated invoice description.",
"uniqueWords" => ["invoice number", "billing address"],
"extractionId" => "updatedExtract123"
],
[
"name" => "Receipt",
"description" => "Retail receipts for in-store purchases.",
"uniqueWords" => ["store id", "cashier", "receipt total"]
]
]
];
try {
$response = updateClassification($token, $classificationId, $classificationDetails);
echo $response;
} catch (Exception $e) {
echo "Failed to update classification: " . $e->getMessage();
}
?>
```
{% endtab %}
{% endtabs %}
## Responses
{% tabs %}
{% tab title="200" %}
```json
{
"status": "updated",
"updatedAt": 1746720927500,
"classificationId": "-OPkce8E1CuEQeHDZetx"
}
```
{% endtab %}
{% tab title="400" %}
```json
{
"status": "error",
"message": "Classification does not exist",
"classificationId": "-OPkce8E1CuEQeHDZetxs"
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"status": "error",
"message": "Error updating classification"
}
```
{% endtab %}
{% endtabs %}
# 4. Delete data
# 4.1 Delete classification
`DELETE` `/documentClassification/deleteClassification`
This endpoint permanently deletes an entire document classification process, including all associated batches, results, and uploaded files.
You must provide only the `classificationId` in the request body. This action is irreversible and removes all data linked to the specified classification.
Use this endpoint when you intend to fully decommission a classification and all its related content. Separate endpoints are available for deleting individual batches or files.
## Server URL
```
https://api.extracta.ai/api/v1
```
## Headers
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
## Body
Name Type Required Description classificationIdstring trueThe classification id.
## Body Example
```json
{
"classificationId": "classificationId"
}
```
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
async function deleteClassification(token, classificationId) {
const url = "https://api.extracta.ai/api/v1/documentClassification/deleteClassification";
try {
const response = await axios.delete(url, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
},
data: {
classificationId: classificationId
}
});
return response.data;
} catch (error) {
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const classificationId = 'classificationId';
try {
const response = await deleteClassification(token, classificationId);
console.log("Classification Deleted:", response);
} catch (error) {
console.error("Failed to delete classification:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def delete_classification(token, classification_id):
url = "https://api.extracta.ai/api/v1/documentClassification/deleteClassification"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {token}"
}
payload = {
"classificationId": classification_id
}
try:
response = requests.delete(url, json=payload, headers=headers)
response.raise_for_status()
return response.json()
except requests.RequestException as e:
print(f"Failed to delete classification: {e}")
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
classification_id = "classificationId"
response = delete_classification(token, classification_id)
if response:
print("Classification Deleted:", response)
else:
print("Failed to delete classification.")
```
{% endtab %}
{% tab title="PHP" %}
```php
$classificationId]);
// Set cURL options
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json',
'Authorization: Bearer ' . $token,
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
try {
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Curl error: ' . curl_error($ch));
}
return $response;
} catch (Exception $e) {
return 'Error: ' . $e->getMessage();
} finally {
curl_close($ch);
}
}
// Example usage
$token = 'apiKey';
$classificationId = 'classificationId';
try {
$response = deleteClassification($token, $classificationId);
echo "Classification Deleted: " . $response;
} catch (Exception $e) {
echo "Failed to delete classification: " . $e->getMessage();
}
?>
```
{% endtab %}
{% endtabs %}
## Responses
{% tabs %}
{% tab title="200" %}
```json
{
"status": "success",
"message": "Classification deleted"
}
```
{% endtab %}
{% tab title="400" %}
```json
{
"status": "success",
"message": "Classification deleted"
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"status": "error",
"message": "Internal server error"
}
```
{% endtab %}
{% endtabs %}
# 4.2 Delete batch
`DELETE` `/documentClassification/deleteBatch`
This endpoint permanently deletes a specific batch from a document classification process.
You must provide both the `classificationId` and the `batchId` in the request body. This action is irreversible and will remove the selected batch along with all results and files associated with it.
Use this endpoint when you need to clean up or remove a specific batch without affecting the overall classification. Separate endpoints are available for deleting entire classifications or individual files.
## Server URL
```
https://api.extracta.ai/api/v1
```
## Headers
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
## Body
Name Type Required Description classificationIdstring trueThe classification id. batchIdstring trueThe batch id.
## Body Example
```json
{
"classificationId": "classificationId",
"batchId": "batchId"
}
```
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
async function deleteBatch(token, classificationId, batchId) {
const url = "https://api.extracta.ai/api/v1/documentClassification/deleteBatch";
try {
const response = await axios.delete(url, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
},
data: {
classificationId: classificationId,
batchId: batchId
}
});
return response.data;
} catch (error) {
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const classificationId = 'classificationId';
const batchId = 'batchId';
try {
const response = await deleteBatch(token, classificationId, batchId);
console.log("Batch Deleted:", response);
} catch (error) {
console.error("Failed to delete batch:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def delete_batch(token, classification_id, batch_id):
url = "https://api.extracta.ai/api/v1/documentClassification/deleteBatch"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {token}"
}
payload = {
"classificationId": classification_id,
"batchId": batch_id
}
try:
response = requests.delete(url, json=payload, headers=headers)
response.raise_for_status()
return response.json()
except requests.RequestException as e:
print(f"Failed to delete classification: {e}")
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
classification_id = "classificationId"
batch_id = "batchId"
response = delete_batch(token, classification_id, batch_id)
if response:
print("Batch Deleted:", response)
else:
print("Failed to delete batch.")
```
{% endtab %}
{% tab title="PHP" %}
```php
$classificationId,
'batchId' => $batchId
]);
// Set cURL options
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json',
'Authorization: Bearer ' . $token,
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
try {
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Curl error: ' . curl_error($ch));
}
return $response;
} catch (Exception $e) {
return 'Error: ' . $e->getMessage();
} finally {
curl_close($ch);
}
}
// Example usage
$token = 'apiKey';
$classificationId = 'classificationId';
$batchId = 'batchId';
try {
$response = deleteBatch($token, $classificationId, $batchId);
echo "Batch Deleted: " . $response;
} catch (Exception $e) {
echo "Failed to delete batch: " . $e->getMessage();
}
?>
```
{% endtab %}
{% endtabs %}
## Responses
{% tabs %}
{% tab title="200" %}
```json
{
"status": "success",
"message": "Batch deleted"
}
```
{% endtab %}
{% tab title="400" %}
```json
{
"status": "success",
"message": "Batch deleted"
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"status": "error",
"message": "Internal server error"
}
```
{% endtab %}
{% endtabs %}
# 4.3 Delete files
`DELETE` `/documentClassification/deleteFiles`
This endpoint permanently deletes one or more specific files from a batch within a document classification process.
You must provide the `classificationId`, `batchId`, and a list of `fileIds` in the request body. This action is irreversible and will remove the specified files and their associated results, without affecting the rest of the batch or classification.
Use this endpoint to precisely remove files without deleting the entire batch or classification. Separate endpoints exist for deleting entire classifications or batches.
## Server URL
```
https://api.extracta.ai/api/v1
```
## Headers
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
## Body
Name Type Required Description classificationIdstring trueThe classification id. batchIdstring trueThe batch id. fileIdslist<string> trueA list of specific file ids.
## Body Example
```json
{
"classificationId": "classificationId",
"batchId": "batchId",
"fileIds": ["fileId1", "fileId2", "fileId3"]
}
```
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
async function deleteFiles(token, classificationId, batchId, fileIds) {
const url = "https://api.extracta.ai/api/v1/documentClassification/deleteFiles";
try {
const response = await axios.delete(url, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
},
data: {
classificationId: classificationId,
batchId: batchId,
fileIds: fileIds
}
});
return response.data;
} catch (error) {
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const classificationId = 'classificationId';
const batchId = 'batchId';
const fileIds = ["fileId1", "fileId2", "fileId3"];
try {
const response = await deleteFiles(token, classificationId, batchId, fileIds);
console.log("Files Deleted:", response);
} catch (error) {
console.error("Failed to delete files:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def delete_files(token, classification_id, batch_id, file_ids):
url = "https://api.extracta.ai/api/v1/documentClassification/deleteFiles"
headers = {
"Content-Type": "application/json",
"Authorization": f"Bearer {token}"
}
payload = {
"classificationId": classification_id,
"batchId": batch_id,
"fileIds": file_ids
}
try:
response = requests.delete(url, json=payload, headers=headers)
response.raise_for_status()
return response.json()
except requests.RequestException as e:
print(f"Failed to delete classification: {e}")
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
classification_id = "classificationId"
batch_id = "batchId"
file_ids = ["fileId1", "fileId2", "fileId3"]
response = delete_batch(token, classification_id, batch_id, file_ids)
if response:
print("Files Deleted:", response)
else:
print("Failed to delete files.")
```
{% endtab %}
{% tab title="PHP" %}
```php
$classificationId,
'batchId' => $batchId,
'fileIds' => $fileIds
]);
// Set cURL options
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'DELETE');
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json',
'Authorization: Bearer ' . $token,
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
try {
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Curl error: ' . curl_error($ch));
}
return $response;
} catch (Exception $e) {
return 'Error: ' . $e->getMessage();
} finally {
curl_close($ch);
}
}
// Example usage
$token = 'apiKey';
$classificationId = 'classificationId';
$batchId = 'batchId';
$fileIds = ['fileId1', 'fileId2', 'fileId3'];
try {
$response = deleteFiles($token, $classificationId, $batchId, $fileIds);
echo "Files Deleted: " . $response;
} catch (Exception $e) {
echo "Failed to delete files: " . $e->getMessage();
}
?>
```
{% endtab %}
{% endtabs %}
## Responses
{% tabs %}
{% tab title="200" %}
```json
{
"status": "success",
"message": "Files deleted"
}
```
{% endtab %}
{% tab title="400" %}
```json
{
"status": "success",
"message": "Files deleted"
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"status": "error",
"message": "Internal server error"
}
```
{% endtab %}
{% endtabs %}
# 5. Upload Files
`POST` `/documentClassification/deleteFiles`
This endpoint enables users to upload files to a specific document classification process.
If a `batchId` is provided in the request, the uploaded files will be added to that existing batch. If `batchId` is omitted, a new batch will be automatically created for the files under the specified `classificationId`.
Files must be uploaded using the `multipart/form-data` content type, which is required for binary file uploads such as PDFs, images, or scanned documents. Ensure the `classificationId` is valid, and that any provided `batchId` already exists within the classification context.
## Server URL
```
https://api.extracta.ai/api/v1
```
## Headers
| Name | Value |
| ------------- | --------------------- |
| Content-Type | `multipart/form-data` |
| Authorization | `Bearer ` |
## Body
Name Type Required Description classificationIdstring trueUnique identifier for the extraction. batchIdstring falseThe ID of the batch to add files to. filesmultipart true/pages/GEp82eoMVXcJO7dA0Z4j
For a seamless classification process, please ensure your documents are in one of our supported formats. Check our Supported File Types page for a list of all formats we currently accept and additional details to prepare your files accordingly.
{% content-ref url="/pages/GEp82eoMVXcJO7dA0Z4j" %}
[Broken mention](broken://pages/GEp82eoMVXcJO7dA0Z4j)
{% endcontent-ref %}
## Code Example
**Note for PHP Users:** Currently, the `/uploadFiles` endpoint supports uploading only one file per request. Please ensure you submit individual requests for each file you need to upload.
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const fs = require('fs');
const axios = require('axios');
const FormData = require('form-data');
async function uploadFilesToClassification(token, classificationId, files, batchId = null) {
const url = "https://api.extracta.ai/api/v1/documentClassification/uploadFiles";
let formData = new FormData();
formData.append('classificationId', classificationId);
if (batchId) {
formData.append('batchId', batchId);
}
files.forEach(file => {
formData.append('files', fs.createReadStream(file));
});
try {
const response = await axios.post(url, formData, {
headers: {
...formData.getHeaders(),
'Authorization': `Bearer ${token}`
}
});
return response.data;
} catch (error) {
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const classificationId = 'classificationId';
const files = ['test_1.pdf', 'test_2.jpg'];
const batchId = null; // or specify an existing batchId if needed
try {
const response = await uploadFilesToClassification(token, classificationId, files, batchId);
console.log("Upload Response:", response);
} catch (error) {
console.error("Failed to upload files:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
import mimetypes
def upload_files_to_classification(token, classification_id, files, batch_id=None):
url = "https://api.extracta.ai/api/v1/documentClassification/uploadFiles"
headers = {"Authorization": f"Bearer {token}"}
# Prepare the files for uploading
file_streams = [
(
"files",
(
file,
open(file, "rb"),
mimetypes.guess_type(file)[0] or "application/octet-stream",
),
)
for file in files
]
payload = {"classificationId": classification_id}
if batch_id is not None:
payload["batchId"] = batch_id
try:
response = requests.post(url, files=file_streams, data=payload, headers=headers)
response.raise_for_status()
return response.json()
except requests.HTTPError as e:
if response.status_code >= 400:
try:
print("Server returned an error:", response.json())
except Exception:
print("Server returned an error:", response.text)
else:
print(f"HTTP error occurred: {e}")
except requests.RequestException as e:
print(f"Failed to upload files: {e}")
except Exception as e:
print(f"An unexpected error occurred: {e}")
return None
# Example usage
if __name__ == "__main__":
token = 'apiKey'
classification_id = 'classificationId'
files = ['test_1.pdf', 'test_2.jpg']
batch_id = None # or specify an existing batch ID if needed
response = upload_files_to_classification(token, classification_id, files, batch_id)
if response:
print("Upload response:", response)
else:
print("Upload failed.")
```
{% endtab %}
{% tab title="PHP" %}
```php
$classificationId,
'files' => new CURLFile($filePath, mime_content_type($filePath), basename($filePath))
];
if ($batchId !== null) {
$payload['batchId'] = $batchId;
}
// Set cURL options
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Authorization: Bearer ' . $token,
'Content-Type: multipart/form-data'
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
try {
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Curl error: ' . curl_error($ch));
}
return $response;
} catch (Exception $e) {
return 'Error: ' . $e->getMessage();
} finally {
curl_close($ch);
}
}
// Example usage
$token = 'apiKey';
$classificationId = 'yourClassificationIdHere';
$filePath = './test_1.pdf';
$batchId = null; // or specify an existing batch ID
try {
$response = uploadFileToClassification($token, $classificationId, $filePath, $batchId);
echo $response;
} catch (Exception $e) {
echo "Failed to upload file: " . $e->getMessage();
}
?>
```
{% endtab %}
{% endtabs %}
## Responses
{% tabs %}
{% tab title="200" %}
```json
{
"status": "uploaded",
"classificationId": "classificationId",
"batchId": "batchId",
"files": [
{
"fileId": "fileId",
"fileName": "file.pdf",
"numberOfPages": 1,
"url": "fileUrl"
}
]
}
```
{% endtab %}
{% tab title="400" %}
```json
{
"status": "error",
"message": "Classification not found"
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"status": "error",
"message": "Internal server error"
}
```
{% endtab %}
{% endtabs %}
# 6. Get results
`POST` `/documentClassification/getResults`
This endpoint retrieves the classification results for a specific batch of documents.
By providing the `classificationId` and `batchId`, you can obtain the predicted document types for each file in the batch,.
Optionally, including a `fileId` will return results for that specific file only. This is useful for retrieving targeted results without querying the entire batch.
## Server URL
```
https://api.extracta.ai/api/v1
```
## Headers
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
## Body
Name Type Required Description classificationIdstring trueThe ID of the classification. batchIdstring trueThe ID of the batch. fileIdstring falseThe ID of the file.
## Body Example
```json
{
"classificationId": "classificationId",
"batchId": "batchId",
"fileId": "fileId" // optional
}
```
## ⚠️ Important
To avoid rate-limiting, please ensure a delay of 2 seconds between consecutive requests to this endpoint.
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
async function getClassificationResults(token, classificationId, batchId, fileId) {
const url = "https://api.extracta.ai/api/v1/documentClassification/getResults";
try {
const payload = {
classificationId,
batchId
};
if (fileId) {
payload.fileId = fileId;
}
const response = await axios.post(url, payload, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
return response.data;
} catch (error) {
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const classificationId = 'classificationId';
const batchId = 'batchId';
const fileId = null; // or provide a specific file ID
try {
const results = await getClassificationResults(token, classificationId, batchId, fileId);
console.log("Classification Results:", results);
} catch (error) {
console.error("Failed to retrieve classification results:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def get_classification_results(token, classification_id, batch_id, file_id=None):
url = "https://api.extracta.ai/api/v1/documentClassification/getResults"
headers = {
'Content-Type': 'application/json',
'Authorization': f'Bearer {token}'
}
payload = {
'classificationId': classification_id,
'batchId': batch_id
}
if file_id:
payload['fileId'] = file_id
response = requests.post(url, json=payload, headers=headers)
if response.status_code == 200:
return response.json()
else:
response.raise_for_status()
# Example usage
if __name__ == "__main__":
token = 'apiKey'
classification_id = 'classificationId'
batch_id = 'batchId'
file_id = None # Or use a specific file ID like 'file123'
try:
results = get_classification_results(token, classification_id, batch_id, file_id)
print("Classification Results:", results)
except Exception as e:
print("Failed to retrieve classification results:", e)
```
{% endtab %}
{% tab title="PHP" %}
```php
$classificationId,
'batchId' => $batchId
];
if ($fileId !== null) {
$payload['fileId'] = $fileId;
}
$payload = json_encode($payload);
// Set cURL options
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
'Content-Type: application/json',
'Authorization: Bearer ' . $token,
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, 1);
try {
$response = curl_exec($ch);
if (curl_errno($ch)) {
throw new Exception('Curl error: ' . curl_error($ch));
}
return $response;
} catch (Exception $e) {
return 'Error: ' . $e->getMessage();
} finally {
curl_close($ch);
}
}
// Example usage
$token = 'apiKey';
$classificationId = 'classificationId';
$batchId = 'batchId';
$fileId = null; // or 'yourFileId' if you want to filter by file
try {
$results = getClassificationResults($token, $classificationId, $batchId, $fileId);
echo $results;
} catch (Exception $e) {
echo "Failed to retrieve classification results: " . $e->getMessage();
}
?>
```
{% endtab %}
{% endtabs %}
## Responses
In case a file is linked to an extraction template, the response will also include an **`extraction`** object with:
* `extractionId` → the ID of the created extraction job
* `batchId` → the batch in which the file was processed
* `fileId` → the ID of the file that was uploaded and processed in the **data extraction module**
{% tabs %}
{% tab title="200 for all files" %}
```json
{
"status": "success",
"classificationId": "classificationId",
"batchId": "batchId",
"files": [
{
"fileId": "fileId1",
"fileName": "File 1.pdf",
"status": "processed",
"result": {
"confidence": 0.9,
"documentType": "invoice"
},
"url": "fileUrl"
},
{
"fileId": "fileId1",
"fileName": "File 2.pdf",
"status": "processed",
"result": {
"confidence": 0.95,
"documentType": "resume"
},
"extraction": {
"extractionId": "extractionId",
"batchId": "batchId",
"fileId": "fileId"
},
"url": "fileUrl"
},
{
"fileId": "fileId2",
"fileName": "File 3.pdf",
"status": "processed",
"result": {
"confidence": 0.95,
"documentType": "other"
},
"url": "fileUrl"
},
...
]
}
```
{% endtab %}
{% tab title="200 for a single file" %}
```json
{
"status": "success",
"classificationId": "classificationId",
"batchId": "batchId",
"fileId": "fileId",
"files": [
{
"fileId": "fileId",
"fileName": "File 1.pdf",
"status": "processed",
"result": {
"confidence": 0.9,
"documentType": "invoice"
},
"url": "fileUrl"
}
]
}
```
{% endtab %}
{% tab title="200 status waiting" %}
```json
{
"status": "waiting",
"classificationId": "-OPXQuIrkHuA2QZkY-44",
"batchId": "8pMpPs6SMPBpcnnznoaRz8bsj"
}
```
{% endtab %}
{% tab title="400" %}
```json
{
"status": "error",
"message": "Internal server error"
}
```
{% endtab %}
{% endtabs %}
# Classification Details
# Document Types
In Extracta's document classification system, a `Document Type` defines a category of documents you expect to classify—such as invoices, receipts, contracts, or purchase orders. Each document type helps the system determine how to interpret and route the documents you upload.
## 🧩 Whats a Document Type?
A documentType is a JSON object with the following fields:
Field Type Required Description namestring✅ A clear, human-readable label for the document type (e.g., "Invoice"). descriptionstring✅ A short explanation of the type of documents this represents. uniqueWordslist<string>✅ A list of key terms or phrases likely to appear in this document type. extractionIdstring❌ ID of a pre-configured extraction template to auto-extract data.
## 📌 Why Unique Words Matter?
The `uniqueWords` array is critical to helping our classification model distinguish between document types. These are **keywords or phrases** commonly found in that document type. Think of them like clues for classification.
```json
"uniqueWords": [
"invoice number",
"bill to",
"total amount"
]
```
This helps the classifier recognize invoices based on visible cues.
## ⚙️ Linking to Extraction Templates
You can optionally link a `documentType` to an existing **extraction template** using `extractionId`. This allows you to:
1. Upload a batch of documents for classification.
2. Have each document automatically classified (e.g., as an "Invoice").
3. Automatically trigger **data extraction** for that document using the associated template.
This creates a powerful end-to-end flow: **classification ➝ structured data extraction**.
## 🧾 Example Definition
Here’s how a `documentTypes` array might look:
```json
"documentTypes": [
{
"name": "Invoice",
"description": "Standard commercial invoice from vendors or suppliers.",
"uniqueWords": ["invoice number", "bill to", "total amount"],
"extractionId": "invoiceExtractionId"
},
{
"name": "Purchase Order",
"description": "Internal or external purchase order documents.",
"uniqueWords": ["PO number", "item description", "quantity ordered"]
},
{
"name": "Receipt",
"description": "Retail or online transaction receipts.",
"uniqueWords": ["receipt", "paid", "transaction id"]
}
]
```
# Postman Integration
* **Set Up Your Environment:**
* Configure your variables in **Collection -> Variables** to include your **API key**.
* How to make an API Key: [Authentication](/api-reference/authentication)
* **Import the file in Postman as in the screenshot below:**
JSON Body
```json
{
"extractionDetails": {
"name": "Custom document - Extraction",
"language": "English",
"fields": [
{
"key": "name",
"description": "the name of the person in the CV",
"example": "Johan Smith"
},
{
"key": "email",
"description": "the email of the person in the CV",
"example": "johan@gmail.com"
},
{
"key": "phone",
"description": "the phone number of the person",
"example": "123 333 4445"
},
{
"key": "address",
"description": "the compelte address of the person",
"example": "1234 Main St, New York, NY 10001"
},
{
"key": "soft_skills",
"description": "the soft skills of the person",
"example": ""
},
{
"key": "hard_skills",
"description": "the hard skills of the person",
"example": ""
},
{
"key": "last_job",
"description": "the last job of the person",
"example": "Software Engineer"
},
{
"key": "years_of_experience",
"description": "the years of experience of last job",
"example": "5"
}
]
}
}
```
## Customizing Your Request
1. **Define Your Fields**: These fields should reflect the unique aspects of your custom document type.
2. **Prepare the API Call**: Incorporate the JSON template into your `POST` request body to `/createExtraction`. Ensure your API key is included in the header as a Bearer token for authentication.
3. **Process the Extracted Data**: After submitting your request, the API will analyze your document and return structured data based on the custom fields you defined, ready for integration into your systems.
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
/**
* Initiates a new document extraction process with the provided details.
*
* @param {string} token - The authorization token for API access.
* @param {Object} extractionDetails - The details of the extraction to be created.
* @returns {Promise} The promise that resolves to the API response with the new extraction ID.
*/
async function createExtraction(token, extractionDetails) {
const url = "https://api.extracta.ai/api/v1/createExtraction";
try {
const response = await axios.post(url, {
extractionDetails
}, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
// Handling response
return response.data; // Directly return the parsed JSON response
} catch (error) {
// Handling errors
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const extractionDetails = {}; // the json body from the example
try {
const response = await createExtraction(token, extractionDetails);
console.log("New Extraction Created:", response);
} catch (error) {
console.error("Failed to create new extraction:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def create_extraction(token, extraction_details):
url = "https://api.extracta.ai/api/v1/createExtraction"
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
try:
response = requests.post(url, json=extraction_details, headers=headers)
response.raise_for_status() # Raises an HTTPError if the response status code is 4XX/5XX
return response.json() # Returns the parsed JSON response
except requests.RequestException as e:
# Handles any requests-related errors
print(e)
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
extraction_details = {} # the json body from the example
response = create_extraction(token, extraction_details)
print("New Extraction Created:", response)
```
{% endtab %}
{% endtabs %}
## Conclusion
With Extracta LABS, the complexity of parsing custom document types is simplified, enabling businesses to focus on deriving value from their data rather than on the intricacies of data extraction. Our customizable approach ensures that you can adapt the API to fit the unique needs of your documents, facilitating efficient data handling and analysis.
For detailed guidance on API integration and making the most of Extracta LABS’s capabilities, please explore our [API Endpoints - Data Extraction](/data-extraction-api/api-endpoints-data-extraction) and [1. Create extraction](/data-extraction-api/api-endpoints-data-extraction/1.-create-extraction) pages.
# Resume / CV
Unlock the full potential of resume data with Extracta LABS’s advanced document parsing capabilities. Our API simplifies the process of extracting valuable information from resumes, making it easier for HR professionals, recruiters, and job portals to automate candidate data extraction, enhancing the recruitment process. This page provides you with a ready-to-use request body for creating resume extractions, streamlining your integration with our service.
## Why Use Extracta LABS for Resume Parsing?
* **Automated Data Extraction**: Reduce manual data entry and speed up the candidate screening process.
* **High Accuracy**: Leverage Extracta LABS's advanced algorithms to ensure precise extraction of candidate information.
* **Customizable Extraction**: Tailor the data extraction to meet your specific recruitment needs.
## Getting Started
To begin parsing resumes with Extracta LABS, you'll need to make a `POST` request to our `/createExtraction` endpoint. Below is a template for the request body specifically designed for resume parsing. This template includes predefined keys that correspond to common data points found in resumes, such as personal information, education, work experience, and skills.
## Body Example for Resume / CV
JSON Body
```json
{
"extractionDetails": {
"name": "Resume - Extraction",
"language": "English",
"fields": [
{
"key": "personal_info",
"description": "personal information of the person",
"type": "object",
"properties": [
{
"key": "name",
"description": "name of the person",
"example": "Alex Smith",
"type": "string"
},
{
"key": "email",
"description": "email of the person",
"example": "alex.smith@gmail.com",
"type": "string"
},
{
"key": "phone",
"description": "phone of the person",
"example": "0712 123 123",
"type": "string"
},
{
"key": "address",
"description": "address of the person",
"example": "Bucharest, Romania",
"type": "string"
}
]
},
{
"key": "work_experience",
"description": "work experience of the person",
"type": "array",
"items": {
"type": "object",
"properties": [
{
"key": "title",
"description": "title of the job",
"example": "Software Engineer",
"type": "string"
},
{
"key": "start_date",
"description": "start date of the job",
"example": "2022",
"type": "string"
},
{
"key": "end_date",
"description": "end date of the job",
"example": "2023",
"type": "string"
},
{
"key": "company",
"description": "company of the job",
"example": "Fastapp Development",
"type": "string"
},
{
"key": "location",
"description": "location of the job",
"example": "Bucharest, Romania",
"type": "string"
},
{
"key": "description",
"description": "description of the job",
"example": "Designing and implementing server-side logic to ensure high performance and responsiveness of applications.",
"type": "string"
}
]
}
},
{
"key": "education",
"description": "school education of the person",
"type": "array",
"items": {
"type": "object",
"properties": [
{
"key": "title",
"description": "title of the education",
"example": "Master of Science in Computer Science",
"type": "string"
},
{
"key": "start_date",
"description": "start date of the education",
"example": "2022",
"type": "string"
},
{
"key": "end_date",
"description": "end date of the education",
"example": "2023",
"type": "string"
},
{
"key": "institute",
"description": "institute of the education",
"example": "Bucharest Academy of Economic Studies",
"type": "string"
},
{
"key": "location",
"description": "location of the education",
"example": "Bucharest, Romania",
"type": "string"
},
{
"key": "description",
"description": "description of the education",
"example": "Advanced academic degree focusing on developing a deep understanding of theoretical foundations and practical applications of computer technology.",
"type": "string"
}
]
}
},
{
"key": "languages",
"description": "languages spoken by the person",
"type": "array",
"items": {
"type": "string",
"example": "English"
}
},
{
"key": "skills",
"description": "skills of the person",
"type": "array",
"items": {
"type": "string",
"example": "NodeJS"
}
},
{
"key": "certificates",
"description": "certificates of the person",
"type": "array",
"items": {
"type": "string",
"example": "AWS Certified Developer - Associate"
}
}
]
}
}
```
## How to Use This Template
1. **Create an API Key**: Ensure you have an API key by signing up at [https://app.extracta.ai](https://app.extracta.ai/) and navigating to the `/api` page to generate your key.
2. **Make the API Call**: Use the provided JSON template in your `POST` request to `/createExtraction`. Don’t forget to include your API key in the request header as a Bearer token for authentication.
3. **Receive and Process Data**: After submitting your request, the API will return structured data extracted from the resume, which you can then integrate into your application or workflow.
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
/**
* Initiates a new document extraction process with the provided details.
*
* @param {string} token - The authorization token for API access.
* @param {Object} extractionDetails - The details of the extraction to be created.
* @returns {Promise} The promise that resolves to the API response with the new extraction ID.
*/
async function createExtraction(token, extractionDetails) {
const url = "https://api.extracta.ai/api/v1/createExtraction";
try {
const response = await axios.post(url, {
extractionDetails
}, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
// Handling response
return response.data; // Directly return the parsed JSON response
} catch (error) {
// Handling errors
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const extractionDetails = {}; // the json body from the example
try {
const response = await createExtraction(token, extractionDetails);
console.log("New Extraction Created:", response);
} catch (error) {
console.error("Failed to create new extraction:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def create_extraction(token, extraction_details):
url = "https://api.extracta.ai/api/v1/createExtraction"
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
try:
response = requests.post(url, json=extraction_details, headers=headers)
response.raise_for_status() # Raises an HTTPError if the response status code is 4XX/5XX
return response.json() # Returns the parsed JSON response
except requests.RequestException as e:
# Handles any requests-related errors
print(e)
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
extraction_details = {} # the json body from the example
response = create_extraction(token, extraction_details)
print("New Extraction Created:", response)
```
{% endtab %}
{% endtabs %}
## Conclusion
Extracta LABS streamlines the extraction of critical information from resumes, offering a powerful tool for anyone looking to automate and improve the efficiency of their recruitment process. By utilizing our API, you can focus on what truly matters - finding the right candidates.
For further details on integrating our API and making the most out of its capabilities, please refer to our [API Endpoints - Data Extraction](/data-extraction-api/api-endpoints-data-extraction) and [1. Create extraction](/data-extraction-api/api-endpoints-data-extraction/1.-create-extraction) pages.
# Contract
Maximize the efficiency of contract management with Extracta LABS’s cutting-edge document parsing technology. Our API is designed to automate the extraction of key information from contracts, aiding legal teams, contract managers, and businesses in streamlining contract analysis and compliance checks. This page provides you with a request body template for creating contract extractions, making it easy to integrate our service into your workflow.
## Why Use Extracta LABS for Contract Parsing?
* **Streamlined Contract Review**: Automate the extraction of key clauses, dates, and obligations.
* **Enhanced Compliance**: Easily identify and manage compliance requirements across contracts.
* **Customizable Data Extraction**: Focus on the specific details that matter most to your contract management process.
## Getting Started
To initiate contract parsing with Extracta LABS, you'll need to perform a `POST` request to our `/createExtraction` endpoint using a template tailored for contract documents. This template includes predefined keys that match typical contract elements, facilitating precise data extraction.
## Body Example for Contract
JSON Body
```json
{
"extractionDetails": {
"name": "Contract - Extraction",
"language": "English",
"fields": [
{
"key": "contract_details",
"description": "contract details",
"type": "object",
"properties": [
{
"key": "contract_number",
"example": "56-2024",
"type": "string"
},
{
"key": "contract_date",
"example": "April 20, 2024",
"type": "string"
}
]
},
{
"key": "involved_parties",
"description": "information about the two parties involved in the contract",
"type": "array",
"items": {
"type": "object",
"properties": [
{
"key": "name",
"type": "string"
},
{
"key": "address",
"type": "string"
},
{
"key": "legal_representative",
"type": "string"
},
{
"key": "position",
"type": "string"
}
]
}
},
{
"key": "contract_object",
"description": "description of the contract object",
"type": "string",
"example": "Design and development of a web application as per the specifications in the attached Project Brief (Document A)"
},
{
"key": "obligations",
"description": "obligations of the involved parties",
"type": "object",
"properties": [
{
"key": "developer_obligations",
"example": "Design and develop a web application, deliver by September 1, 2024, make necessary adjustments within 30 days of delivery",
"type": "string"
},
{
"key": "client_obligations",
"example": "Pay the total fee in stages, test the application and provide feedback within 30 days of delivery",
"type": "string"
}
]
},
{
"key": "contract_duration",
"type": "string",
"example": "12 months"
},
{
"key": "contract_price",
"type": "string",
"example": "$200,000"
}
]
}
}
```
## How to Use This Template
1. **Generate an API Key**: If you haven’t already, sign up at [https://app.extracta.ai](https://app.extracta.ai/) and navigate to the `/api` page to create your API key.
2. **Execute the API Call**: Incorporate the JSON template in your `POST` request to `/createExtraction`. Remember to authenticate your request by including your API key as a Bearer token in the request header.
3. **Process the Extracted Data**: Upon submitting your request, the API will return structured data extracted from the contract, ready to be utilized in your systems or processes.
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
/**
* Initiates a new document extraction process with the provided details.
*
* @param {string} token - The authorization token for API access.
* @param {Object} extractionDetails - The details of the extraction to be created.
* @returns {Promise} The promise that resolves to the API response with the new extraction ID.
*/
async function createExtraction(token, extractionDetails) {
const url = "https://api.extracta.ai/api/v1/createExtraction";
try {
const response = await axios.post(url, {
extractionDetails
}, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
// Handling response
return response.data; // Directly return the parsed JSON response
} catch (error) {
// Handling errors
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const extractionDetails = {}; // the json body from the example
try {
const response = await createExtraction(token, extractionDetails);
console.log("New Extraction Created:", response);
} catch (error) {
console.error("Failed to create new extraction:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def create_extraction(token, extraction_details):
url = "https://api.extracta.ai/api/v1/createExtraction"
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
try:
response = requests.post(url, json=extraction_details, headers=headers)
response.raise_for_status() # Raises an HTTPError if the response status code is 4XX/5XX
return response.json() # Returns the parsed JSON response
except requests.RequestException as e:
# Handles any requests-related errors
print(e)
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
extraction_details = {} # the json body from the example
response = create_extraction(token, extraction_details)
print("New Extraction Created:", response)
```
{% endtab %}
{% endtabs %}
## Conclusion
With Extracta LABS, navigating through the complexities of contract analysis becomes a streamlined, automated process. Our API empowers you to focus on strategic aspects of contract management by handling the tedious task of data extraction.
For further details on integrating our API and making the most out of its capabilities, please refer to our [API Endpoints - Data Extraction](/data-extraction-api/api-endpoints-data-extraction) and [1. Create extraction](/data-extraction-api/api-endpoints-data-extraction/1.-create-extraction) pages.
# Business Card
Transform your contract management process with Extracta’s cutting-edge document parsing capabilities. Our API facilitates the extraction of key information from contracts, empowering legal teams, procurement departments, and businesses to automate data extraction, thereby enhancing contract analysis and management efficiency. This page offers a specialized request body template for contract parsing, designed to streamline your integration with our service.
## Why Extracta LABS for Contract Parsing?
* **Efficient Data Extraction**: Automate the extraction of critical contract elements, such as parties involved, terms, conditions, and obligations.
* **High Accuracy and Intelligence**: Utilize Extracta’s advanced algorithms for high-precision data extraction.
* **Customizable and Scalable**: Adapt the data extraction to suit specific business needs, scalable for organizations of any size.
## Getting Started
Initiate the process of parsing contracts through Extracta LABS by making a `POST` request to our `/createExtraction` endpoint. Below, we provide a request body template tailored for contract parsing. This template is preconfigured with keys for standard contract elements, streamlining the extraction process.
## Body Example for Business Card
JSON Body
```json
{
"extractionDetails": {
"name": "Business Card - Extraction",
"language": "English",
"fields": [
{
"key": "name",
"description": "Name of the person in the business card",
"example": "Bardahan Alexandru"
},
{
"key": "job_title",
"description": "Job title of the person",
"example": "CEO"
},
{
"key": "company_name",
"description": "Extract company name from card; if absent, deduce from email, website, or social domains.",
"example": "Fastapp Development"
},
{
"key": "address",
"description": "Address of the company",
"example": "Bucharest, Romania"
},
{
"key": "phone_numbers",
"type": "array",
"items": {
"type": "string",
"example": "+40 755 852 411"
}
},
{
"key": "email_addresses",
"type": "array",
"items": {
"type": "string",
"example": "office@fastappgroup.com"
}
},
{
"key": "website_url",
"description": "Website url of the company",
"example": "https://fastappgroup.com"
},
{
"key": "social_media_handles",
"description": "Social media handles of the company",
"type": "array",
"items": {
"type": "object",
"properties": [
{
"key": "type",
"description": "Type of the social media handle",
"example": "facebook"
},
{
"key": "username",
"description": "Username of the social media handle",
"example": "fastappgroup"
}
]
}
}
]
}
}
```
#### How to Use This Template
1. **Generate an API Key**: Sign up at [https://app.extracta.ai](https://app.extracta.ai/) and visit the `/api` page to create your API key.
2. **Execute the API Call**: Employ the JSON template in a `POST` request to `/createExtraction`, incorporating your API key in the request header as a Bearer token for authentication.
3. **Process the Extracted Data**: The API will respond with structured data extracted from the contract, ready for integration into your systems or workflows.
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
/**
* Initiates a new document extraction process with the provided details.
*
* @param {string} token - The authorization token for API access.
* @param {Object} extractionDetails - The details of the extraction to be created.
* @returns {Promise} The promise that resolves to the API response with the new extraction ID.
*/
async function createExtraction(token, extractionDetails) {
const url = "https://api.extracta.ai/api/v1/createExtraction";
try {
const response = await axios.post(url, {
extractionDetails
}, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
// Handling response
return response.data; // Directly return the parsed JSON response
} catch (error) {
// Handling errors
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const extractionDetails = {}; // the json body from the example
try {
const response = await createExtraction(token, extractionDetails);
console.log("New Extraction Created:", response);
} catch (error) {
console.error("Failed to create new extraction:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def create_extraction(token, extraction_details):
url = "https://api.extracta.ai/api/v1/createExtraction"
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
try:
response = requests.post(url, json=extraction_details, headers=headers)
response.raise_for_status() # Raises an HTTPError if the response status code is 4XX/5XX
return response.json() # Returns the parsed JSON response
except requests.RequestException as e:
# Handles any requests-related errors
print(e)
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
extraction_details = {} # the json body from the example
response = create_extraction(token, extraction_details)
print("New Extraction Created:", response)
```
{% endtab %}
{% endtabs %}
## Conclusion
Leverage Extracta LABS to elevate your contract management processes, from faster data retrieval to more informed decision-making. Our API not only simplifies the extraction of crucial contract details but also integrates seamlessly into various CRM platforms like Zoho, Salesforce, and HubSpot, enhancing your workflow automation.
For comprehensive instructions on integrating our API and leveraging its full capabilities, please refer to our [API Endpoints - Data Extraction](/data-extraction-api/api-endpoints-data-extraction) and [1. Create extraction](/data-extraction-api/api-endpoints-data-extraction/1.-create-extraction) pages.
# Email
Extracta LABS revolutionizes the way businesses handle email data through our Email Parsing API. By automating the extraction of text, attachments, and other relevant information from emails, we empower businesses to streamline their workflows, improve data management, and enhance business intelligence. This guide provides you with the essentials for integrating email parsing into your applications using our API.
## Why Extracta LABS for Email Parsing?
* **Comprehensive Data Extraction**: From body text to attachments, capture every piece of valuable information.
* **High Precision**: Benefit from Extracta’s advanced OCR and text processing technologies for accurate data extraction.
* **Custom Workflows**: Easily integrate extracted data into your CRM, database, or custom workflow for immediate use.
## Getting Started
Integrating email parsing into your system starts with a simple `POST` request to our `/createExtraction` endpoint, utilizing a request body designed for email data. Below, we provide a JSON template tailored for email parsing, highlighting the key information segments typically extracted from emails.
## Body Example for Email
JSON Body
```json
{
"extractionDetails": {
"name": "Email Data Extraction",
"language": "English",
"fields": [
{
"key": "email_info",
"type": "object",
"properties": [
{
"key": "Subject Line",
"description": "The subject of the email"
},
{
"key": "Email Date",
"description": "The date the email was sent",
"example": "February 20, 2024"
}
]
},
{
"key": "sender_info",
"type": "object",
"properties": [
{
"key": "Sender Name",
"description": "The name of the person who sent the email"
},
{
"key": "Sender Email",
"description": "The email address of the sender"
},
{
"key": "Sender's Position",
"description": "The job title of the sender",
"example": "Project Manager"
},
{
"key": "Sender's Contact Number",
"description": "The phone number of the sender"
}
]
},
{
"key": "recipient",
"type": "object",
"properties": [
{
"key": "Recipient Name",
"description": "The name of the email's recipient"
},
{
"key": "Recipient Email",
"description": "The email address of the recipient"
}
]
},
{
"key": "cc",
"description": "Carbon copy recipients of the email",
"type": "array",
"items": {
"type": "string",
"example": "test@gmail.com"
}
},
{
"key": "bcc",
"description": "Blind carbon copy recipients of the email",
"type": "array",
"items": {
"type": "string",
"example": "test@gmail.com"
}
},
{
"key": "meeting_info",
"description": "Information about the meeting",
"type": "object",
"properties": [
{
"key": "Meeting Date",
"example": "February 25, 2024"
},
{
"key": "Meeting Time",
"example": "10:00 AM"
},
{
"key": "Meeting Location",
"example": "Bucharest, Romania"
}
]
},
{
"key": "project_name",
"description": "The name of the project being discussed"
},
{
"key": "proposal_equirements",
"description": "Specific requirements or topics requested in the proposal",
"type": "array",
"items": {
"type": "string",
"example": "Integration of AI technologies"
}
}
]
}
}
```
## How to Implement
1. **API Key Generation**: First, sign up at [https://app.extracta.ai](https://app.extracta.ai/) and create an API key on the `/api` page.
2. **API Request**: Use the JSON template in a `POST` request to `/createExtraction`, including your API key in the header for authentication.
3. **Data Integration**: The API's response will contain structured data extracted from the email, ready for integration into your system.
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
/**
* Initiates a new document extraction process with the provided details.
*
* @param {string} token - The authorization token for API access.
* @param {Object} extractionDetails - The details of the extraction to be created.
* @returns {Promise} The promise that resolves to the API response with the new extraction ID.
*/
async function createExtraction(token, extractionDetails) {
const url = "https://api.extracta.ai/api/v1/createExtraction";
try {
const response = await axios.post(url, {
extractionDetails
}, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
// Handling response
return response.data; // Directly return the parsed JSON response
} catch (error) {
// Handling errors
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const extractionDetails = {}; // the json body from the example
try {
const response = await createExtraction(token, extractionDetails);
console.log("New Extraction Created:", response);
} catch (error) {
console.error("Failed to create new extraction:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def create_extraction(token, extraction_details):
url = "https://api.extracta.ai/api/v1/createExtraction"
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
try:
response = requests.post(url, json=extraction_details, headers=headers)
response.raise_for_status() # Raises an HTTPError if the response status code is 4XX/5XX
return response.json() # Returns the parsed JSON response
except requests.RequestException as e:
# Handles any requests-related errors
print(e)
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
extraction_details = {} # the json body from the example
response = create_extraction(token, extraction_details)
print("New Extraction Created:", response)
```
{% endtab %}
{% endtabs %}
## Maximize Your Data Potential
With Extracta LABS, transforming unstructured email data into actionable insights has never been easier. Our Email Parsing API is a powerful tool for businesses looking to automate data extraction from emails for CRM updates, database enrichment, batch processing, or business intelligence analysis.
Explore further details on our API’s capabilities by visiting our [API Endpoints - Data Extraction](/data-extraction-api/api-endpoints-data-extraction) and our [1. Create extraction](/data-extraction-api/api-endpoints-data-extraction/1.-create-extraction) pages.
# Invoice
Transform the way you process invoices with Extracta's cutting-edge document parsing capabilities. Our API is specifically designed to automate the extraction of detailed invoice data, facilitating faster, more accurate accounts payable and receivable processes. This guide provides you with a tailored request body for creating invoice extractions, making it easier to integrate our technology into your financial workflows.
## Why Choose Extracta LABS for Invoice Parsing?
* **Efficient Processing**: Automate the extraction of invoice data to accelerate your financial operations.
* **High Precision**: Depend on our advanced OCR and machine learning technologies for accurate data capture.
* **Flexibility**: Extract data from invoices in various formats, including PDF, PNG, and JPG.
* **Custom Extraction**: Specify the data you need, from vendor details to line items, for tailored results.
## Getting Started
To initiate invoice data extraction, execute a `POST` request to the `/createExtraction` endpoint using the following request body template. This template is pre-configured with keys for common invoice data points, ensuring a streamlined setup for your extraction needs.
## Body Example for Invoice
JSON Body
````json
{
"extractionDetails": {
"name": "Invoice - Extraction",
"language": "English",
"options": {
"hasTable": true,
"handwrittenTextRecognition": false
},
"fields": [
{
"key": "invoice_id",
"example": "1234567890",
"type": "string"
},
{
"key": "invoice_date",
"description": "the invoice date in the following format yyyy-mm-dd",
"example": "2022-01-01",
"type": "string"
},
{
"key": "invoice_tax_rate",
"description": "the tax rate of the invoice",
"example": "19%",
"type": "string"
},
{
"key": "invoice_currency",
"description": "the currency of the invoice. return one of the following: RON, EUR, USD, LEI, etc.",
"example": "Lei",
"type": "string"
},
{
"key": "client",
"description": "the client in the invoice",
"type": "object",
"properties": [
{
"key": "client_name",
"description": "name of the client",
"example": "NovaTech Innovations",
"type": "string"
},
{
"key": "client_address",
"description": "address of the client",
"example": "1234 Main St, New York, NY 10001",
"type": "string"
},
{
"key": "client_tax_id",
"description": "tax id or vat id of the client",
"example": "987654321",
"type": "string"
}
]
},
{
"key": "merchant",
"description": "the merchant in the invoice",
"type": "object",
"properties": [
{
"key": "merchant_name",
"description": "name of the merchant",
"example": "Galactic Solutions",
"type": "string"
},
{
"key": "merchant_address",
"description": "address of the merchant",
"example": "789 Elm Rd, Seattle, WA 98109",
"type": "string"
},
{
"key": "merchant_tax_id",
"description": "tax id or vat id of the merchant",
"example": "123987456",
"type": "string"
}
]
},
{
"key": "items",
"description": "the items in the invoice",
"type": "array",
"items": {
"type": "object",
"properties": [
{
"key": "name",
"description": "the name of the item",
"example": "Item 1",
"type": "string"
},
{
"key": "quantity",
"description": "the quantity of the item",
"example": "1",
"type": "string"
},
{
"key": "unit_price",
"description": "the unit price of the item. return only the number as a string.",
"example": "100.00",
"type": "string"
},
{
"key": "total_price",
"description": "the total price of the item. return only the number as a string.",
"example": "100.00",
"type": "string"
},
{
"key": "tax",
"description": "the total tax of the item. return only the number as a string.",
"example": "100.00",
"type": "string"
}
]
}
},
{
"key": "invoice_sub_total",
"description": "The total amount before tax is applied. This may correspond to 'Total' or similar terms before tax addition. Return only the number as a string.",
"example": "863.03",
"type": "string"
},
{
"key": "invoice_tax_amount",
"description": "The amount of tax charged on the invoice. This is the tax figure listed separately from the sub-total. Return only the number as a string.",
"example": "163.97",
"type": "string"
},
{
"key": "invoice_grand_total",
"description": "The total amount after tax has been added. This should capture the final payable amount. Return only the number as a string.",
"example": "1027.00",
"type": "string"
}
]
},
"file": "https://deveatery.com/extracta/invoice.png"
}
```
````
## How to Apply This Template
1. **Obtain an API Key**: Sign up at [https://app.extracta.ai](https://app.extracta.ai/) and visit the `/api` page to generate your unique API key.
2. **Craft Your API Request**: Incorporate the JSON template in a `POST` request to `/createExtraction`. Remember to authenticate your request by including your API key as a Bearer token in the request header.
3. **Process the Extracted Data**: Once the API processes your request, it will return structured data extracted from the invoice, ready for integration into your financial systems.
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
/**
* Initiates a new document extraction process with the provided details.
*
* @param {string} token - The authorization token for API access.
* @param {Object} extractionDetails - The details of the extraction to be created.
* @returns {Promise} The promise that resolves to the API response with the new extraction ID.
*/
async function createExtraction(token, extractionDetails) {
const url = "https://api.extracta.ai/api/v1/createExtraction";
try {
const response = await axios.post(url, {
extractionDetails
}, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
// Handling response
return response.data; // Directly return the parsed JSON response
} catch (error) {
// Handling errors
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const extractionDetails = {}; // the json body from the example
try {
const response = await createExtraction(token, extractionDetails);
console.log("New Extraction Created:", response);
} catch (error) {
console.error("Failed to create new extraction:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def create_extraction(token, extraction_details):
url = "https://api.extracta.ai/api/v1/createExtraction"
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
try:
response = requests.post(url, json=extraction_details, headers=headers)
response.raise_for_status() # Raises an HTTPError if the response status code is 4XX/5XX
return response.json() # Returns the parsed JSON response
except requests.RequestException as e:
# Handles any requests-related errors
print(e)
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
extraction_details = {} # the json body from the example
response = create_extraction(token, extraction_details)
print("New Extraction Created:", response)
```
{% endtab %}
{% endtabs %}
## Conclusion
Leverage Extracta LABS to modernize your invoice processing, reducing manual data entry and enhancing the accuracy of your financial operations. Our API simplifies the task of digitizing, capturing, and structuring data from scanned invoices, allowing you to focus on strategic financial management.
Explore our [API Endpoints - Data Extraction](/data-extraction-api/api-endpoints-data-extraction) and [1. Create extraction](/data-extraction-api/api-endpoints-data-extraction/1.-create-extraction) pages for more insights on integrating Extracta LABS into your document processing workflow.
# Receipt
Transform your receipt processing with Extracta’s cutting-edge document parsing capabilities. Our API is designed to automate the extraction of data from receipts, ideal for retailers, financial institutions, and any business that needs to analyze purchase data efficiently. This page guides you through using our API for receipt parsing, featuring a pre-configured request body template for immediate use.
## Why Extracta LABS for Receipt Parsing?
* **Streamline Financial Workflows**: Automate the capture and analysis of receipt data to speed up accounting processes and financial reporting.
* **Enhanced Accuracy**: Benefit from high precision OCR and data parsing technology that minimizes errors in financial analysis.
* **Custom Data Extraction**: Extract only the data you need, from transaction dates and amounts to item descriptions and merchant information.
## Getting Started
To extract data from receipts using Extracta LABS, you will need to send a `POST` request to our `/createExtraction` endpoint with a specific request body designed for receipt data. Below, we provide a template that includes predefined keys for common receipt information fields.
## Body Example for Receipt
JSON Body
```json
{
"extractionDetails": {
"name": "Receipt - Extraction",
"language": "English",
"options": {
"hasTable": true,
"handwrittenTextRecognition": false
},
"fields": [
{
"key": "receipt_id",
"example": "1234567890",
"type": "string"
},
{
"key": "receipt_date",
"description": "the invoice date in the following format yyyy-mm-dd",
"example": "2022-01-01",
"type": "string"
},
{
"key": "merchant",
"description": "the merchant in the invoice",
"type": "object",
"properties": [
{
"key": "merchant_name",
"description": "name of the merchant",
"example": "Galactic Solutions",
"type": "string"
},
{
"key": "merchant_address",
"description": "address of the merchant",
"example": "789 Elm Rd, Seattle, WA 98109",
"type": "string"
},
{
"key": "merchant_tax_id",
"description": "tax id or vat id of the merchant",
"example": "123987456",
"type": "string"
}
]
},
{
"key": "items",
"description": "the items in the receipt",
"type": "array",
"items": {
"type": "object",
"properties": [
{
"key": "name",
"example": "Item 1",
"type": "string"
},
{
"key": "quantity",
"example": "1",
"type": "string"
},
{
"key": "unit_price",
"description": "return only the number as a string.",
"example": "100.00",
"type": "string"
},
{
"key": "total_price",
"description": "return only the number as a string.",
"example": "100.00",
"type": "string"
}
]
}
},
{
"key": "total_tax_amount",
"description": "The amount of tax charged on the invoice. This is the tax figure listed separately from the sub-total. Return only the number as a string.",
"example": "163.97",
"type": "string"
},
{
"key": "grand_total",
"description": "The total amount after tax has been added. This should capture the final payable amount. Return only the number as a string.",
"example": "1027.00",
"type": "string"
}
]
}
}
```
## Utilizing the Template
1. **Obtain an API Key**: First, ensure you have an API key by registering at [https://app.extracta.ai](https://app.extracta.ai/) and creating your key on the `/api` page.
2. **Execute the API Request**: Incorporate the JSON template in your `POST` request to `/createExtraction`, including your API key in the header for authentication.
3. **Integrate Extracted Data**: The API will process your receipt and return detailed, structured data, ready to be integrated into your financial systems or applications.
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
/**
* Initiates a new document extraction process with the provided details.
*
* @param {string} token - The authorization token for API access.
* @param {Object} extractionDetails - The details of the extraction to be created.
* @returns {Promise} The promise that resolves to the API response with the new extraction ID.
*/
async function createExtraction(token, extractionDetails) {
const url = "https://api.extracta.ai/api/v1/createExtraction";
try {
const response = await axios.post(url, {
extractionDetails
}, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
// Handling response
return response.data; // Directly return the parsed JSON response
} catch (error) {
// Handling errors
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const extractionDetails = {}; // the json body from the example
try {
const response = await createExtraction(token, extractionDetails);
console.log("New Extraction Created:", response);
} catch (error) {
console.error("Failed to create new extraction:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def create_extraction(token, extraction_details):
url = "https://api.extracta.ai/api/v1/createExtraction"
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
try:
response = requests.post(url, json=extraction_details, headers=headers)
response.raise_for_status() # Raises an HTTPError if the response status code is 4XX/5XX
return response.json() # Returns the parsed JSON response
except requests.RequestException as e:
# Handles any requests-related errors
print(e)
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
extraction_details = {} # the json body from the example
response = create_extraction(token, extraction_details)
print("New Extraction Created:", response)
```
{% endtab %}
{% endtabs %}
## Leveraging Receipt Data
With Extracta LABS, you can unlock the potential of your receipt data, automating and refining financial processes with our advanced parsing technology. This not only saves time but also provides accurate, actionable insights from your transactional documents.
For more information on how to integrate Extracta LABS into your workflows, refer to our detailed [API Endpoints - Data Extraction](/data-extraction-api/api-endpoints-data-extraction) and [1. Create extraction](/data-extraction-api/api-endpoints-data-extraction/1.-create-extraction) pages.
# Bank Statement
Transform the way you process financial documents with Extracta’s cutting-edge bank statement parsing capabilities. Our API is engineered to automate the extraction of financial data from bank statements, making it an indispensable tool for financial institutions, accounting software, and fintech startups. This guide provides a detailed overview of using a pre-defined request body for efficient bank statement parsing, ensuring a smooth integration with our platform.
## Why Choose Extracta LABS for Bank Statement Parsing?
* **Streamlined Data Extraction**: Automate the retrieval of transaction data, account balances, and other financial information.
* **OCR and AI-Powered**: Benefit from advanced OCR and AI technologies for high-precision reading of both digital and scanned bank statements.
* **Custom Extraction Paths**: Tailor the data extraction process to fit your specific requirements for financial analysis and reporting.
## Getting Started
To initiate the parsing of bank statements, you will need to execute a `POST` request to our `/createExtraction` endpoint. Below, we provide a request body template designed specifically for bank statement parsing. This template outlines predefined keys that are essential for extracting data from bank statements, such as transactions, account details, and summary.
## Body Example for Bank Statement
JSON Body
```json
{
"extractionDetails": {
"name": "Bank Check - Extraction",
"language": "English",
"fields": [
{
"key": "amount",
"example": "25"
},
{
"key": "amount_text",
"example": "Twenty-five and no/100"
},
{
"key": "bank_address"
},
{
"key": "bank_name",
"example": "WASHINGTON'S OLDEST NATIONAL BANK FIRST NATIONAL BANK"
},
{
"key": "date",
"example": "2019-10-13"
},
{
"key": "memo",
"example": "world hunger relief"
},
{
"key": "payer_name",
"example": "HON. GERALD R. FORD MRS. BETTY B. FORD"
},
{
"key": "payer_address",
"example": "1600 PENNSYLVANIA AVE. WASHINGTON, DC 20500"
},
{
"key": "receiver_name",
"example": "Presiding Bishop, Episcopal Church"
},
{
"key": "receiver_address",
"example": "815 Second Avenue, New York, NY 10017"
},
{
"key": "currency",
"example": "USD",
"description": "currency as string, not symbol"
},
{
"key": "micr_raw",
"example": "A0540D0004A C140611 6C B0000002500B"
},
{
"key": "account_number",
"example": "6111611",
"description": "Part of the MICR line, typically at the end."
},
{
"key": "routing_number",
"example": "05400004",
"description": "Part of the MICR line, typically in the middle."
},
{
"key": "check_number",
"example": "878",
"description": "Located at the top right of the check."
}
]
}
}
```
## How to Implement This Template
1. **Generate an API Key**: First, create an account on [https://app.extracta.ai](https://app.extracta.ai/) and visit the `/api` page to obtain your API key.
2. **API Call Execution**: Utilize the JSON template in your `POST` request to `/createExtraction`, incorporating your API key in the request header as a Bearer token.
3. **Data Integration**: Once the API processes your request, you will receive structured data from the bank statement, ready for integration into your system or workflow.
## Code Example
{% tabs %}
{% tab title="JavaScript" %}
```javascript
const axios = require('axios');
/**
* Initiates a new document extraction process with the provided details.
*
* @param {string} token - The authorization token for API access.
* @param {Object} extractionDetails - The details of the extraction to be created.
* @returns {Promise} The promise that resolves to the API response with the new extraction ID.
*/
async function createExtraction(token, extractionDetails) {
const url = "https://api.extracta.ai/api/v1/createExtraction";
try {
const response = await axios.post(url, {
extractionDetails
}, {
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
}
});
// Handling response
return response.data; // Directly return the parsed JSON response
} catch (error) {
// Handling errors
throw error.response ? error.response.data : new Error('An unknown error occurred');
}
}
async function main() {
const token = 'apiKey';
const extractionDetails = {}; // the json body from the example
try {
const response = await createExtraction(token, extractionDetails);
console.log("New Extraction Created:", response);
} catch (error) {
console.error("Failed to create new extraction:", error);
}
}
main();
```
{% endtab %}
{% tab title="Python" %}
```python
import requests
def create_extraction(token, extraction_details):
url = "https://api.extracta.ai/api/v1/createExtraction"
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {token}"}
try:
response = requests.post(url, json=extraction_details, headers=headers)
response.raise_for_status() # Raises an HTTPError if the response status code is 4XX/5XX
return response.json() # Returns the parsed JSON response
except requests.RequestException as e:
# Handles any requests-related errors
print(e)
return None
# Example usage
if __name__ == "__main__":
token = "apiKey"
extraction_details = {} # the json body from the example
response = create_extraction(token, extraction_details)
print("New Extraction Created:", response)
```
{% endtab %}
{% endtabs %}
## Conclusion
With Extracta LABS, parsing bank statements becomes an automated, accurate, and efficient part of your financial document processing workflow. Our API leverages the latest in OCR and AI technologies to provide you with the data you need when you need it, ensuring your financial analyses are always informed by the most up-to-date information.
Explore further integration details and maximize the potential of our API by visiting our [API Endpoints - Data Extraction](/data-extraction-api/api-endpoints-data-extraction) and [1. Create extraction](/data-extraction-api/api-endpoints-data-extraction/1.-create-extraction) pages.
# Tutorials
Welcome to the Extracta.ai tutorials page! Here, we provide step-by-step guides to help you get started with our API. Whether you're new to Extracta.ai or looking to explore more advanced features, these tutorials are designed to equip you with the knowledge to integrate our API seamlessly into your workflows.
## Getting Started
### How to Make an Account and Obtain an API Key
1. **Sign Up**: Visit [https://app.extracta.ai](https://app.extracta.ai/) and sign up for an account to get started.
2. **Generate API Key**: Once logged in, navigate to the `/api` section of your dashboard. Here, you can generate a new API key by clicking on the "Generate API Key" button.
3. **Keep Your API Key Secure**: Store your API key in a safe place. It's your unique identifier and grants access to the API's capabilities.
{% content-ref url="/pages/nVOqzbgiuFMfYJFfSxNq" %}
[Authentication](/api-reference/authentication)
{% endcontent-ref %}
### First API Call: Creating an Extraction
Learn how to make your first API call to create an extraction template. This tutorial covers the basics of forming a request to our `/createExtraction` endpoint.
{% content-ref url="/pages/Kr8TtNYErc3zJQQ68V7K" %}
[1. Create extraction](/data-extraction-api/api-endpoints-data-extraction/1.-create-extraction)
{% endcontent-ref %}
## Postman Collection
For a complete and interactive set of API requests, please refer to our [Postman Integration](/data-extraction-api/postman-integration) collection.
## Document Types
### Parsing a Resume
This tutorial walks you through the process of extracting data from a resume using a predefined template. It includes steps for preparing the request and handling the extracted data.
{% content-ref url="/pages/QpnjK5EoHo2OnV9R5HLN" %}
[Resume / CV](/documents/resume-cv)
{% endcontent-ref %}
### Working with Custom Documents
Discover how to parse custom documents by specifying your own fields for extraction. This guide provides insights into customizing your extraction request for various document types.
{% content-ref url="/pages/zInUxfskFjgVjNXxdAy5" %}
[Custom Document](/documents/custom-document)
{% endcontent-ref %}
## Advanced Topics
### Batch Processing
Learn how to upload and process documents in batches, a feature that enhances efficiency by handling multiple documents in a single request.
{% content-ref url="/pages/sWhIeG7Es4VBfiHRfeYw" %}
[5. Upload Files](/data-extraction-api/api-endpoints-data-extraction/5.-upload-files)
{% endcontent-ref %}
### Receiving Batch Results: Polling vs. Webhook
This tutorial explains the two methods of receiving batch results: polling and using a webhook for real-time updates. Understand the pros and cons of each method and how to implement them.
{% content-ref url="/pages/xXq6iSQKgPG6jmHJXdgA" %}
[Polling vs Webhook](/data-extraction-api/polling-vs-webhook)
{% endcontent-ref %}
## FAQ
Find answers to common questions about using the Extracta.ai API, troubleshooting, and best practices.
{% content-ref url="/pages/dhCn1MEQki1HiLNMzR52" %}
[FAQ](/contact/faq)
{% endcontent-ref %}
## Need More Help?
If you encounter any issues or have further questions, our support team is here to assist you. Visit our Contact page for more information.
{% content-ref url="/pages/dpJM2AKMBKrLy4SW1M9M" %}
[Contact Us](/contact/contact-us)
{% endcontent-ref %}
# Contact Us
At Extracta LABS, we are committed to providing exceptional support and ensuring that your experience with our product is as seamless and productive as possible. Whether you have questions, feedback, or need assistance, our team is here to help.
## Get in Touch
### Email Support
For support or any inquiries, please email us at:
* **Email:**
### Phone Support
For immediate assistance, you can reach us by phone during business hours:
* **Phone:** +40 755 852 411
* **Hours:** Monday to Friday, 9 AM to 5 PM (GMT)
### Live Chat
Visit our website and use the live chat feature for real-time support from our team. Available during business hours.
### Social Media
Follow us on our social media channels to stay updated on the latest news, updates, and announcements:
* **LinkedIn:**
* **Reddit:**
# FAQ
Welcome to the Extracta LABS FAQ page! Here, you'll find answers to some of the most common questions about our Document Parsing API, how to use it, and what you can expect. If your question isn't answered here, please don't hesitate to contact us.
What is Extracta LABS?
Extracta LABS is a cutting-edge technology platform that specialises in extracting structured data from any type of document (like CVs and invoices). Our service is designed to automate workflows, replace manual data processing, and enhance efficiency across various industries.
What types of documents can we process?
We can process a wide range of documents both structured and unstructured, including PDFs, Word documents, text files, and scanned images (PNG, JPG) using OCR technology where necessary.
Is our platform GDPR compliant?
Absolutely. Both our web platform and API are fully GDPR compliant. We prioritize data privacy and security in all our operations.
Can it be integrated into existing systems?
Yes, Extracta LABS is designed for seamless integration. You can connect our service to your existing software and workflows through our API. Additionally, in the future we plan to offer deployment on local systems for enhanced data privacy.
How do we differ from our competitors?
Unlike competitors that rely on predefined templates and models, Extracta LABS uses fine-tuned LLMs to extract data from any document without prior training, offering up to 99% accuracy. This allows for greater flexibility and faster implementation at lower costs.
What pricing models do we offer?
We offer our solution on a Pay-per-request basis, ensuring flexibility and scalability for our clients. We also provide a free trial to test our platform before committing.
Where can I find technical support or have other questions answered?
Our dedicated support team is available to assist you with any technical queries or further information. Please reach out to us through our website's contact form or support chat. Also, feel free to check our tutorials and documentation.