Document Moderation

This section covers all APIs related to document moderation, including manual editing of field values, verification status tracking, and document-level moderation.

Field Management

Update Field Value

Manually update a field value and track moderation.

PATCH /api/v4/workflows/{workflow_id}/documents/{document_id}/pages/{page_id}/fields/{field_data_id}

Overview

• Updates a specific field value using its unique ID
• Tracks original and moderated values
• Records moderation timestamp and user
• Maintains verification status
• Useful for manual corrections
• Preserves audit trail

Request

{
  "value": "INV-2024-003"
}

Response

{
  "field_data_id": "f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5",
  "field_name": "invoice_number",
  "value": "INV-2024-003",
  "bbox": [100, 200, 300, 250],
  "confidence": 0.95,
  "verification_status": "unverified",
  "verification_message": ""
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
PAGE_ID = '550e8400-e29b-41d4-a716-446655440002'
FIELD_DATA_ID = 'f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/pages/{PAGE_ID}/fields/{FIELD_DATA_ID}"

payload = {
    "value": "INV-2024-003"
}

response = requests.patch(
    url,
    json=payload,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X PATCH \
  -u "YOUR_API_KEY:" \
  -H "Content-Type: application/json" \
  -d '{
    "value": "INV-2024-003"
  }' \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/pages/550e8400-e29b-41d4-a716-446655440002/fields/f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const PAGE_ID = '550e8400-e29b-41d4-a716-446655440002';
const FIELD_DATA_ID = 'f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/pages/${PAGE_ID}/fields/${FIELD_DATA_ID}`;

const payload = {
  value: "INV-2024-003"
};

axios.patch(url, payload, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
    "bytes"
)

type FieldUpdatePayload struct {
    Value string `json:"value"`
}

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    PAGE_ID := "550e8400-e29b-41d4-a716-446655440002"
    FIELD_DATA_ID := "f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/pages/%s/fields/%s",
        WORKFLOW_ID, DOCUMENT_ID, PAGE_ID, FIELD_DATA_ID)

    payload := FieldUpdatePayload{
        Value: "INV-2024-003",
    }

    jsonData, err := json.Marshal(payload)
    if err != nil {
        fmt.Println(err)
        return
    }

    req, err := http.NewRequest("PATCH", url, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Add Field Value

Add a new field value to a document.

POST /api/v4/workflows/{workflow_id}/documents/{document_id}/pages/{page_id}/fields

Overview

• Adds a new field value to a specific page in a document
• Includes bounding box coordinates
• Sets initial verification status
• Useful for manual data entry
• Preserves audit trail

Request

{
  "field_name": "invoice_number",
  "value": "INV-2024-004",
  "bbox": [100, 200, 300, 250],
  "confidence": 1.0,
  "verification_status": "unverified",
  "verification_message": ""
}

Response

{
  "field_data_id": "f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5",
  "field_name": "invoice_number",
  "value": "INV-2024-004",
  "bbox": [100, 200, 300, 250],
  "confidence": 1.0,
  "verification_status": "unverified",
  "verification_message": ""
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
PAGE_ID = '550e8400-e29b-41d4-a716-446655440002'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/pages/{PAGE_ID}/fields"

payload = {
    "field_name": "invoice_number",
    "value": "INV-2024-004",
    "bbox": [100, 200, 300, 250],
    "confidence": 1.0,
    "verification_status": "unverified",
    "verification_message": ""
}

response = requests.post(
    url,
    json=payload,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X POST \
  -u "YOUR_API_KEY:" \
  -H "Content-Type: application/json" \
  -d '{
    "field_name": "invoice_number",
    "value": "INV-2024-004",
    "bbox": [100, 200, 300, 250],
    "confidence": 1.0,
    "verification_status": "unverified",
    "verification_message": ""
  }' \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/pages/550e8400-e29b-41d4-a716-446655440002/fields

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const PAGE_ID = '550e8400-e29b-41d4-a716-446655440002';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/pages/${PAGE_ID}/fields`;

const payload = {
  field_name: "invoice_number",
  value: "INV-2024-004",
  bbox: [100, 200, 300, 250],
  confidence: 1.0,
  verification_status: "unverified",
  verification_message: ""
};

axios.post(url, payload, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
    "bytes"
)

type FieldAddPayload struct {
    FieldName          string    `json:"field_name"`
    Value             string    `json:"value"`
    Bbox              []int     `json:"bbox"`
    Confidence        float64   `json:"confidence"`
    VerificationStatus string   `json:"verification_status"`
    VerificationMessage string  `json:"verification_message"`
}

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    PAGE_ID := "550e8400-e29b-41d4-a716-446655440002"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/pages/%s/fields",
        WORKFLOW_ID, DOCUMENT_ID, PAGE_ID)

    payload := FieldAddPayload{
        FieldName: "invoice_number",
        Value: "INV-2024-004",
        Bbox: []int{100, 200, 300, 250},
        Confidence: 1.0,
        VerificationStatus: "unverified",
        VerificationMessage: "",
    }

    jsonData, err := json.Marshal(payload)
    if err != nil {
        fmt.Println(err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Delete Field Value

Delete a field value from a document.

DELETE /api/v4/workflows/{workflow_id}/documents/{document_id}/pages/{page_id}/fields/{field_data_id}

Overview

• Removes a field value from a document
• Records deletion in moderation history
• Useful for removing incorrect data
• Preserves audit trail

Response

{
  "success": true,
  "message": "Field value deleted successfully"
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
FIELD_DATA_ID = 'f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/pages/{PAGE_ID}/fields/{FIELD_DATA_ID}"

response = requests.delete(
    url,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X DELETE \
  -u "YOUR_API_KEY:" \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/pages/550e8400-e29b-41d4-a716-446655440002/fields/f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const PAGE_ID = '550e8400-e29b-41d4-a716-446655440002';
const FIELD_DATA_ID = 'f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/pages/${PAGE_ID}/fields/${FIELD_DATA_ID}`;

axios.delete(url, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
)

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    PAGE_ID := "550e8400-e29b-41d4-a716-446655440002"
    FIELD_DATA_ID := "f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/pages/%s/fields/%s",
        WORKFLOW_ID, DOCUMENT_ID, PAGE_ID, FIELD_DATA_ID)

    req, err := http.NewRequest("DELETE", url, nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Table Management

Add Table

Add a new table to a document.

POST /api/v4/workflows/{workflow_id}/documents/{document_id}/pages/{page_id}/tables

Overview

• Creates a new table in a document
• Includes table bounding box
• Sets initial verification status
• Allows adding cells during table creation
• Useful for manual table creation
• Preserves audit trail

Request

{
  "bbox": [100, 300, 800, 600],
  "headers": ["item_description", "quantity", "price"],
  "verification_status": "unverified",
  "verification_message": "",
  "cells": [
    {
      "row": 0,
      "col": 0,
      "header": "item_description",
      "text": "Product A",
      "bbox": [100, 330, 300, 360],
      "verification_status": "unverified",
      "verification_message": ""
    },
    {
      "row": 0,
      "col": 1,
      "header": "quantity",
      "text": "5",
      "bbox": [310, 330, 380, 360],
      "verification_status": "unverified",
      "verification_message": ""
    },
    {
      "row": 0,
      "col": 2,
      "header": "price",
      "text": "$100.00",
      "bbox": [390, 330, 480, 360],
      "verification_status": "unverified",
      "verification_message": ""
    }
  ]
}

Response

{
  "table_id": "d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b",
  "bbox": [100, 300, 800, 600],
  "headers": ["item_description", "quantity", "price"],
  "verification_status": "unverified",
  "verification_message": "",
  "cells": [
    {
      "cell_id": "1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1",
      "row": 0,
      "col": 0,
      "header": "item_description",
      "text": "Product A",
      "bbox": [100, 330, 300, 360],
      "verification_status": "unverified",
      "verification_message": ""
    },
    {
      "cell_id": "2c6e4ef8-4ef8-531b-b93c-3aecfef4e2c2",
      "row": 0,
      "col": 1,
      "header": "quantity",
      "text": "5",
      "bbox": [310, 330, 380, 360],
      "verification_status": "unverified",
      "verification_message": ""
    },
    {
      "cell_id": "3d7f5fg9-5fg9-642c-c04d-4bfdgfg5f3d3",
      "row": 0,
      "col": 2,
      "header": "price",
      "text": "$100.00",
      "bbox": [390, 330, 480, 360],
      "verification_status": "unverified",
      "verification_message": ""
    }
  ]
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
PAGE_ID = '550e8400-e29b-41d4-a716-446655440002'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/pages/{PAGE_ID}/tables"

payload = {
    "bbox": [100, 300, 800, 600],
    "headers": ["item_description", "quantity", "price"],
    "verification_status": "unverified",
    "verification_message": "",
    "cells": [
        {
            "row": 0,
            "col": 0,
            "header": "item_description",
            "text": "Product A",
            "bbox": [100, 330, 300, 360],
            "verification_status": "unverified",
            "verification_message": ""
        },
        {
            "row": 0,
            "col": 1,
            "header": "quantity",
            "text": "5",
            "bbox": [310, 330, 380, 360],
            "verification_status": "unverified",
            "verification_message": ""
        },
        {
            "row": 0,
            "col": 2,
            "header": "price",
            "text": "$100.00",
            "bbox": [390, 330, 480, 360],
            "verification_status": "unverified",
            "verification_message": ""
        }
    ]
}

response = requests.post(
    url,
    json=payload,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X POST \
  -u "YOUR_API_KEY:" \
  -H "Content-Type: application/json" \
  -d '{
    "bbox": [100, 300, 800, 600],
    "headers": ["item_description", "quantity", "price"],
    "verification_status": "unverified",
    "verification_message": "",
    "cells": [
      {
        "row": 0,
        "col": 0,
        "header": "item_description",
        "text": "Product A",
        "bbox": [100, 330, 300, 360],
        "verification_status": "unverified",
        "verification_message": ""
      },
      {
        "row": 0,
        "col": 1,
        "header": "quantity",
        "text": "5",
        "bbox": [310, 330, 380, 360],
        "verification_status": "unverified",
        "verification_message": ""
      },
      {
        "row": 0,
        "col": 2,
        "header": "price",
        "text": "$100.00",
        "bbox": [390, 330, 480, 360],
        "verification_status": "unverified",
        "verification_message": ""
      }
    ]
  }' \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/pages/550e8400-e29b-41d4-a716-446655440002/tables

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const PAGE_ID = '550e8400-e29b-41d4-a716-446655440002';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/pages/${PAGE_ID}/tables`;

const payload = {
  bbox: [100, 300, 800, 600],
  headers: ["item_description", "quantity", "price"],
  verification_status: "unverified",
  verification_message: "",
  cells: [
    {
      row: 0,
      col: 0,
      header: "item_description",
      text: "Product A",
      bbox: [100, 330, 300, 360],
      verification_status: "unverified",
      verification_message: ""
    },
    {
      row: 0,
      col: 1,
      header: "quantity",
      text: "5",
      bbox: [310, 330, 380, 360],
      verification_status: "unverified",
      verification_message: ""
    },
    {
      row: 0,
      col: 2,
      header: "price",
      text: "$100.00",
      bbox: [390, 330, 480, 360],
      verification_status: "unverified",
      verification_message: ""
    }
  ]
};

axios.post(url, payload, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
    "bytes"
)

type TableCell struct {
    Row                int      `json:"row"`
    Col                int      `json:"col"`
    Header             string   `json:"header"`
    Text               string   `json:"text"`
    Bbox               []int    `json:"bbox"`
    VerificationStatus string   `json:"verification_status"`
    VerificationMessage string  `json:"verification_message"`
}

type TableAddPayload struct {
    Bbox               []int        `json:"bbox"`
    Headers            []string     `json:"headers"`
    VerificationStatus string       `json:"verification_status"`
    VerificationMessage string      `json:"verification_message"`
    Cells              []TableCell  `json:"cells"`
}

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    PAGE_ID := "550e8400-e29b-41d4-a716-446655440002"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/pages/%s/tables",
        WORKFLOW_ID, DOCUMENT_ID, PAGE_ID)

    payload := TableAddPayload{
        Bbox: []int{100, 300, 800, 600},
        Headers: []string{"item_description", "quantity", "price"},
        VerificationStatus: "unverified",
        VerificationMessage: "",
        Cells: []TableCell{
            {
                Row: 0,
                Col: 0,
                Header: "item_description",
                Text: "Product A",
                Bbox: []int{100, 330, 300, 360},
                VerificationStatus: "unverified",
                VerificationMessage: "",
            },
            {
                Row: 0,
                Col: 1,
                Header: "quantity",
                Text: "5",
                Bbox: []int{310, 330, 380, 360},
                VerificationStatus: "unverified",
                VerificationMessage: "",
            },
            {
                Row: 0,
                Col: 2,
                Header: "price",
                Text: "$100.00",
                Bbox: []int{390, 330, 480, 360},
                VerificationStatus: "unverified",
                VerificationMessage: "",
            },
        },
    }

    jsonData, err := json.Marshal(payload)
    if err != nil {
        fmt.Println(err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Delete Table

Delete a table from a document.

DELETE /api/v4/workflows/{workflow_id}/documents/{document_id}/pages/{page_id}/tables/{table_id}

Overview

• Removes a table from a document
• Records deletion in moderation history
• Useful for removing incorrect tables
• Preserves audit trail

Response

{
  "success": true,
  "message": "Table deleted successfully"
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/pages/{PAGE_ID}/tables/{TABLE_ID}"

response = requests.delete(
    url,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X DELETE \
  -u "YOUR_API_KEY:" \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/pages/550e8400-e29b-41d4-a716-446655440002/tables/d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const PAGE_ID = '550e8400-e29b-41d4-a716-446655440002';
const TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/pages/${PAGE_ID}/tables/${TABLE_ID}`;

axios.delete(url, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
)

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    PAGE_ID := "550e8400-e29b-41d4-a716-446655440002"
    TABLE_ID := "d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/pages/%s/tables/%s",
        WORKFLOW_ID, DOCUMENT_ID, PAGE_ID, TABLE_ID)

    req, err := http.NewRequest("DELETE", url, nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Update Table Cell Value

Manually update a table cell value and track moderation.

PATCH /api/v4/workflows/{workflow_id}/documents/{document_id}/pages/{page_id}/tables/{table_id}/cells/{cell_id}

Overview

• Updates a specific table cell value using its unique ID
• Tracks original and moderated values
• Records moderation timestamp and user
• Maintains verification status
• Useful for manual corrections
• Preserves audit trail

Request

{
  "value": "Product B"
}

Response

{
  "cell_id": "1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1",
  "row": 0,
  "col": 0,
  "header": "item_description",
  "text": "Product B",
  "bbox": [100, 330, 300, 360],
  "verification_status": "unverified",
  "verification_message": ""
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
PAGE_ID = '550e8400-e29b-41d4-a716-446655440002'
TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b'
CELL_ID = '1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/pages/{PAGE_ID}/tables/{TABLE_ID}/cells/{CELL_ID}"

payload = {
    "value": "Product B"
}

response = requests.patch(
    url,
    json=payload,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X PATCH \
  -u "YOUR_API_KEY:" \
  -H "Content-Type: application/json" \
  -d '{
    "value": "Product B"
  }' \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/pages/550e8400-e29b-41d4-a716-446655440002/tables/d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b/cells/1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const PAGE_ID = '550e8400-e29b-41d4-a716-446655440002';
const TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b';
const CELL_ID = '1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/pages/${PAGE_ID}/tables/${TABLE_ID}/cells/${CELL_ID}`;

const payload = {
  value: "Product B"
};

axios.patch(url, payload, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
    "bytes"
)

type TableCellUpdatePayload struct {
    Value string `json:"value"`
}

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    PAGE_ID := "550e8400-e29b-41d4-a716-446655440002"
    TABLE_ID := "d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b"
    CELL_ID := "1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/pages/%s/tables/%s/cells/%s",
        WORKFLOW_ID, DOCUMENT_ID, PAGE_ID, TABLE_ID, CELL_ID)

    payload := TableCellUpdatePayload{
        Value: "Product B",
    }

    jsonData, err := json.Marshal(payload)
    if err != nil {
        fmt.Println(err)
        return
    }

    req, err := http.NewRequest("PATCH", url, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Add Table Cell

Add a new cell to an existing table.

POST /api/v4/workflows/{workflow_id}/documents/{document_id}/pages/{page_id}/tables/{table_id}/cells

Overview

• Adds a new cell to an existing table
• Includes cell bounding box
• Sets initial verification status
• Useful for manual cell addition
• Preserves audit trail

Request

{
  "row": 0,
  "col": 0,
  "header": "item_description",
  "text": "Product A",
  "bbox": [100, 330, 300, 360],
  "verification_status": "unverified",
  "verification_message": ""
}

Response

{
  "cell_id": "1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1",
  "row": 0,
  "col": 0,
  "header": "item_description",
  "text": "Product A",
  "bbox": [100, 330, 300, 360],
  "verification_status": "unverified",
  "verification_message": ""
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
PAGE_ID = '550e8400-e29b-41d4-a716-446655440002'
TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/pages/{PAGE_ID}/tables/{TABLE_ID}/cells"

payload = {
    "row": 0,
    "col": 0,
    "header": "item_description",
    "text": "Product A",
    "bbox": [100, 330, 300, 360],
    "verification_status": "unverified",
    "verification_message": ""
}

response = requests.post(
    url,
    json=payload,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X POST \
  -u "YOUR_API_KEY:" \
  -H "Content-Type: application/json" \
  -d '{
    "row": 0,
    "col": 0,
    "header": "item_description",
    "text": "Product A",
    "bbox": [100, 330, 300, 360],
    "verification_status": "unverified",
    "verification_message": ""
  }' \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/pages/550e8400-e29b-41d4-a716-446655440002/tables/d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b/cells

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const PAGE_ID = '550e8400-e29b-41d4-a716-446655440002';
const TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/pages/${PAGE_ID}/tables/${TABLE_ID}/cells`;

const payload = {
  row: 0,
  col: 0,
  header: "item_description",
  text: "Product A",
  bbox: [100, 330, 300, 360],
  verification_status: "unverified",
  verification_message: ""
};

axios.post(url, payload, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
    "bytes"
)

type TableCellAddPayload struct {
    Row                int      `json:"row"`
    Col                int      `json:"col"`
    Header             string   `json:"header"`
    Text               string   `json:"text"`
    Bbox               []int    `json:"bbox"`
    VerificationStatus string   `json:"verification_status"`
    VerificationMessage string  `json:"verification_message"`
}

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    PAGE_ID := "550e8400-e29b-41d4-a716-446655440002"
    TABLE_ID := "d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/pages/%s/tables/%s/cells",
        WORKFLOW_ID, DOCUMENT_ID, PAGE_ID, TABLE_ID)

    payload := TableCellAddPayload{
        Row: 0,
        Col: 0,
        Header: "item_description",
        Text: "Product A",
        Bbox: []int{100, 330, 300, 360},
        VerificationStatus: "unverified",
        VerificationMessage: "",
    }

    jsonData, err := json.Marshal(payload)
    if err != nil {
        fmt.Println(err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Delete Table Cell

Delete a cell from a table.

DELETE /api/v4/workflows/{workflow_id}/documents/{document_id}/pages/{page_id}/tables/{table_id}/cells/{cell_id}

Overview

• Removes a cell from a table
• Records deletion in moderation history
• Useful for removing incorrect cells
• Preserves audit trail

Response

{
  "success": true,
  "message": "Table cell deleted successfully"
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
PAGE_ID = '550e8400-e29b-41d4-a716-446655440002'
TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b'
CELL_ID = '1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/pages/{PAGE_ID}/tables/{TABLE_ID}/cells/{CELL_ID}"

response = requests.delete(
    url,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X DELETE \
  -u "YOUR_API_KEY:" \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/pages/550e8400-e29b-41d4-a716-446655440002/tables/d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b/cells/1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const PAGE_ID = '550e8400-e29b-41d4-a716-446655440002';
const TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b';
const CELL_ID = '1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/pages/${PAGE_ID}/tables/${TABLE_ID}/cells/${CELL_ID}`;

axios.delete(url, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
)

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    PAGE_ID := "550e8400-e29b-41d4-a716-446655440002"
    TABLE_ID := "d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b"
    CELL_ID := "1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/pages/%s/tables/%s/cells/%s",
        WORKFLOW_ID, DOCUMENT_ID, PAGE_ID, TABLE_ID, CELL_ID)

    req, err := http.NewRequest("DELETE", url, nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Verification

Verify Field

Verify a field in a document.

POST /api/v4/workflows/{workflow_id}/documents/{document_id}/pages/{page_id}/fields/{field_data_id}/verify

Overview

• Marks a field as verified
• Updates verification status
• Records verification in moderation history
• Useful for quality control
• Preserves audit trail

Request

{
  "verification_status": "verified",
  "verification_message": "Field value is correct"
}

Response

{
  "field_data_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "field_name": "invoice_number",
  "value": "INV-2024-001",
  "bbox": [100, 200, 300, 250],
  "confidence": 0.95,
  "verification_status": "verified",
  "verification_message": "Field value is correct"
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
PAGE_ID = '550e8400-e29b-41d4-a716-446655440002'
FIELD_DATA_ID = 'f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/pages/{PAGE_ID}/fields/{FIELD_DATA_ID}/verify"

payload = {
    "verification_status": "verified",
    "verification_message": "Field value is correct"
}

response = requests.post(
    url,
    json=payload,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X POST \
  -u "YOUR_API_KEY:" \
  -H "Content-Type: application/json" \
  -d '{
    "verification_status": "verified",
    "verification_message": "Field value is correct"
  }' \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/pages/550e8400-e29b-41d4-a716-446655440002/fields/f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5/verify

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const PAGE_ID = '550e8400-e29b-41d4-a716-446655440002';
const FIELD_DATA_ID = 'f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/pages/${PAGE_ID}/fields/${FIELD_DATA_ID}/verify`;

const payload = {
  verification_status: "verified",
  verification_message: "Field value is correct"
};

axios.post(url, payload, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
    "bytes"
)

type FieldVerificationPayload struct {
    VerificationStatus  string `json:"verification_status"`
    VerificationMessage string `json:"verification_message"`
}

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    PAGE_ID := "550e8400-e29b-41d4-a716-446655440002"
    FIELD_DATA_ID := "f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/pages/%s/fields/%s/verify",
        WORKFLOW_ID, DOCUMENT_ID, PAGE_ID, FIELD_DATA_ID)

    payload := FieldVerificationPayload{
        VerificationStatus: "verified",
        VerificationMessage: "Field value is correct",
    }

    jsonData, err := json.Marshal(payload)
    if err != nil {
        fmt.Println(err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Verify Table Cell

Verify a table cell in a document.

POST /api/v4/workflows/{workflow_id}/documents/{document_id}/pages/{page_id}/tables/{table_id}/cells/{cell_id}/verify

Overview

• Marks a table cell as verified
• Updates verification status
• Records verification in moderation history
• Useful for quality control
• Preserves audit trail

Request

{
  "verification_status": "verified",
  "verification_message": "Cell value is correct"
}

Response

{
  "cell_id": "1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1",
  "row": 0,
  "col": 0,
  "header": "item_description",
  "text": "Product A",
  "bbox": [100, 330, 300, 360],
  "verification_status": "verified",
  "verification_message": "Cell value is correct"
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
PAGE_ID = '550e8400-e29b-41d4-a716-446655440002'
TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b'
CELL_ID = '1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/pages/{PAGE_ID}/tables/{TABLE_ID}/cells/{CELL_ID}/verify"

payload = {
    "verification_status": "verified",
    "verification_message": "Cell value is correct"
}

response = requests.post(
    url,
    json=payload,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X POST \
  -u "YOUR_API_KEY:" \
  -H "Content-Type: application/json" \
  -d '{
    "verification_status": "verified",
    "verification_message": "Cell value is correct"
  }' \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/pages/550e8400-e29b-41d4-a716-446655440002/tables/d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b/cells/1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1/verify

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const PAGE_ID = '550e8400-e29b-41d4-a716-446655440002';
const TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b';
const CELL_ID = '1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/pages/${PAGE_ID}/tables/${TABLE_ID}/cells/${CELL_ID}/verify`;

const payload = {
  verification_status: "verified",
  verification_message: "Cell value is correct"
};

axios.post(url, payload, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
    "bytes"
)

type TableCellVerificationPayload struct {
    VerificationStatus  string `json:"verification_status"`
    VerificationMessage string `json:"verification_message"`
}

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    PAGE_ID := "550e8400-e29b-41d4-a716-446655440002"
    TABLE_ID := "d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b"
    CELL_ID := "1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/pages/%s/tables/%s/cells/%s/verify",
        WORKFLOW_ID, DOCUMENT_ID, PAGE_ID, TABLE_ID, CELL_ID)

    payload := TableCellVerificationPayload{
        VerificationStatus: "verified",
        VerificationMessage: "Cell value is correct",
    }

    jsonData, err := json.Marshal(payload)
    if err != nil {
        fmt.Println(err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Verify Table

Verify an entire table in a document.

POST /api/v4/workflows/{workflow_id}/documents/{document_id}/pages/{page_id}/tables/{table_id}/verify

Overview

• Marks all cells in a table as verified
• Updates verification status for the table
• Records verification in moderation history
• Useful for bulk table verification
• Preserves audit trail

Request

{
  "verification_status": "verified",
  "verification_message": "All table values are correct"
}

Response

{
  "table_id": "d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b",
  "bbox": [100, 300, 800, 600],
  "headers": ["item_description", "quantity", "price"],
  "verification_status": "verified",
  "verification_message": "All table values are correct",
  "cells": [
    {
      "cell_id": "1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1",
      "row": 0,
      "col": 0,
      "header": "item_description",
      "text": "Product A",
      "bbox": [100, 330, 300, 360],
      "verification_status": "verified",
      "verification_message": ""
    },
    {
      "cell_id": "2c6e4ef8-4ef8-531b-b93c-3aecfef4e2c2",
      "row": 0,
      "col": 1,
      "header": "quantity",
      "text": "5",
      "bbox": [310, 330, 380, 360],
      "verification_status": "verified",
      "verification_message": ""
    },
    {
      "cell_id": "3d7f5fg9-5fg9-642c-c04d-4bfdgfg5f3d3",
      "row": 0,
      "col": 2,
      "header": "price",
      "text": "$100.00",
      "bbox": [390, 330, 480, 360],
      "verification_status": "verified",
      "verification_message": ""
    }
  ]
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
PAGE_ID = '550e8400-e29b-41d4-a716-446655440002'
TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/pages/{PAGE_ID}/tables/{TABLE_ID}/verify"

payload = {
    "verification_status": "verified",
    "verification_message": "All table values are correct"
}

response = requests.post(
    url,
    json=payload,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X POST \
  -u "YOUR_API_KEY:" \
  -H "Content-Type: application/json" \
  -d '{
    "verification_status": "verified",
    "verification_message": "All table values are correct"
  }' \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/pages/550e8400-e29b-41d4-a716-446655440002/tables/d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b/verify

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const PAGE_ID = '550e8400-e29b-41d4-a716-446655440002';
const TABLE_ID = 'd8e5c1d2-4e71-4d0e-babc-a845f2de4f1b';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/pages/${PAGE_ID}/tables/${TABLE_ID}/verify`;

const payload = {
  verification_status: "verified",
  verification_message: "All table values are correct"
};

axios.post(url, payload, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
    "bytes"
)

type TableVerificationPayload struct {
    VerificationStatus  string `json:"verification_status"`
    VerificationMessage string `json:"verification_message"`
}

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    PAGE_ID := "550e8400-e29b-41d4-a716-446655440002"
    TABLE_ID := "d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/pages/%s/tables/%s/verify",
        WORKFLOW_ID, DOCUMENT_ID, PAGE_ID, TABLE_ID)

    payload := TableVerificationPayload{
        VerificationStatus: "verified",
        VerificationMessage: "All table values are correct",
    }

    jsonData, err := json.Marshal(payload)
    if err != nil {
        fmt.Println(err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Verify Document

Verify an entire document.

POST /api/v4/workflows/{workflow_id}/documents/{document_id}/verify

Overview

• Marks all fields and tables in a document as verified
• Updates verification status for all elements
• Records verification in moderation history
• Useful for bulk verification
• Preserves audit trail

Request

{
  "verification_status": "verified",
  "verification_message": "All values are correct"
}

Response

{
  "document_id": "550e8400-e29b-41d4-a716-446655440001",
  "status": "verified",
  "verification_status": "verified",
  "verification_message": "All values are correct",
  "pages": [
    {
      "page_id": "550e8400-e29b-41d4-a716-446655440002",
      "page_number": 1,
      "fields": [
        {
          "field_data_id": "f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5",
          "field_name": "invoice_number",
          "value": "INV-2024-001",
          "bbox": [100, 200, 300, 250],
          "confidence": 0.95,
          "verification_status": "verified",
          "verification_message": ""
        }
      ],
      "tables": [
        {
          "table_id": "d8e5c1d2-4e71-4d0e-babc-a845f2de4f1b",
          "bbox": [100, 300, 800, 600],
          "headers": ["item_description", "quantity", "price"],
          "verification_status": "verified",
          "verification_message": "",
          "cells": [
            {
              "cell_id": "1b5d3df7-3df7-420a-a82b-29dbdfd3e1b1",
              "row": 0,
              "col": 0,
              "header": "item_description",
              "text": "Product A",
              "bbox": [100, 330, 300, 360],
              "verification_status": "verified",
              "verification_message": ""
            }
          ]
        }
      ]
    }
  ]
}

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/verify"

payload = {
    "verification_status": "verified",
    "verification_message": "All values are correct"
}

response = requests.post(
    url,
    json=payload,
    auth=HTTPBasicAuth(API_KEY, '')
)
print(response.json())

cURL

curl -X POST \
  -u "YOUR_API_KEY:" \
  -H "Content-Type: application/json" \
  -d '{
    "verification_status": "verified",
    "verification_message": "All values are correct"
  }' \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/verify

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/verify`;

const payload = {
  verification_status: "verified",
  verification_message: "All values are correct"
};

axios.post(url, payload, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  console.error(error);
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
    "bytes"
)

type DocumentVerificationPayload struct {
    VerificationStatus  string `json:"verification_status"`
    VerificationMessage string `json:"verification_message"`
}

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/verify",
        WORKFLOW_ID, DOCUMENT_ID)

    payload := DocumentVerificationPayload{
        VerificationStatus: "verified",
        VerificationMessage: "All values are correct",
    }

    jsonData, err := json.Marshal(payload)
    if err != nil {
        fmt.Println(err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        fmt.Println(err)
        return
    }

    auth := base64.StdEncoding.EncodeToString([]byte(API_KEY + ":"))
    req.Header.Add("Authorization", "Basic "+auth)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    var result map[string]interface{}
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("%+v\n", result)
}

Error Handling

All document moderation APIs return standard HTTP status codes:

• 200 OK: Request successful
• 400 Bad Request: Invalid request parameters
• 401 Unauthorized: Invalid or missing API key
• 404 Not Found: Workflow, document, field, or table cell not found
• 409 Conflict: Invalid verification status
• 500 Internal Server Error: Server-side error

Common Error Codes

Example

Python

import requests
from requests.auth import HTTPBasicAuth

API_KEY = 'YOUR_API_KEY'
WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000'
DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001'
FIELD_DATA_ID = 'f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5'
url = f"https://app.nanonets.com/api/v4/workflows/{WORKFLOW_ID}/documents/{DOCUMENT_ID}/fields/{FIELD_DATA_ID}"

try:
    response = requests.get(
        url,
        auth=HTTPBasicAuth(API_KEY, '')
    )
    response.raise_for_status()  # Raises an HTTPError for bad responses (4xx, 5xx)
    print(response.json())
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 404:
        print("Field not found")
    elif e.response.status_code == 401:
        print("Unauthorized - Check your API key")
    elif e.response.status_code == 403:
        print("Forbidden - Insufficient permissions")
    else:
        print(f"HTTP Error: {e}")
except requests.exceptions.RequestException as e:
    print(f"Request Error: {e}")

cURL

curl -X GET \
  -u "YOUR_API_KEY:" \
  https://app.nanonets.com/api/v4/workflows/550e8400-e29b-41d4-a716-446655440000/documents/550e8400-e29b-41d4-a716-446655440001/fields/f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5

# Common error responses:
# 404 Not Found
# 401 Unauthorized
# 403 Forbidden

Node.js

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const WORKFLOW_ID = '550e8400-e29b-41d4-a716-446655440000';
const DOCUMENT_ID = '550e8400-e29b-41d4-a716-446655440001';
const FIELD_DATA_ID = 'f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5';
const url = `https://app.nanonets.com/api/v4/workflows/${WORKFLOW_ID}/documents/${DOCUMENT_ID}/fields/${FIELD_DATA_ID}`;

axios.get(url, {
  auth: {
    username: API_KEY,
    password: ''
  }
})
.then(response => {
  console.log(response.data);
})
.catch(error => {
  if (error.response) {
    switch (error.response.status) {
      case 404:
        console.error('Field not found');
        break;
      case 401:
        console.error('Unauthorized - Check your API key');
        break;
      case 403:
        console.error('Forbidden - Insufficient permissions');
        break;
      default:
        console.error(`HTTP Error: ${error.message}`);
    }
  } else if (error.request) {
    console.error('Request Error:', error.message);
  } else {
    console.error('Error:', error.message);
  }
});

Go

package main

import (
    "fmt"
    "net/http"
    "encoding/base64"
    "encoding/json"
    "io/ioutil"
)

func main() {
    API_KEY := "YOUR_API_KEY"
    WORKFLOW_ID := "550e8400-e29b-41d4-a716-446655440000"
    DOCUMENT_ID := "550e8400-e29b-41d4-a716-446655440001"
    FIELD_DATA_ID := "f1a2b3c4-d5e6-4f7g-8h9i-j0k1l2m3n4o5"
    url := fmt.Sprintf("https://app.nanonets.com/api/v4/workflows/%s/documents/%s/fields/%s",
        WORKFLOW_ID, DOCUMENT_ID, FIELD_DATA_ID)

    try:
        response = requests.get(
            url,
            auth=HTTPBasicAuth(API_KEY, '')
        )
        response.raise_for_status()  # Raises an HTTPError for bad responses (4xx, 5xx)
        print(response.json())
    except requests.exceptions.HTTPError as e:
        if e.response.status_code == 404:
            print("Field not found")
        elif e.response.status_code == 401:
            print("Unauthorized - Check your API key")
        elif e.response.status_code == 403:
            print("Forbidden - Insufficient permissions")
        else:
            print(f"HTTP Error: {e}")
    except requests.exceptions.RequestException as e:
        print(f"Request Error: {e}")

Best Practices

1. Field and Table Cell Moderation

   • Verify each field and cell individually
   • Add clear verification notes
   • Track all modifications

2. Document Verification

   • Verify all fields and cells before marking document as verified
   • Include comprehensive verification notes
   • Maintain audit trail

3. Moderation History

   • Review moderation history regularly
   • Use history for quality control
   • Track common issues

For more best practices, refer to the Best Practices Guide.