API Reference
API Reference
Start typing to search…

Document Moderation

Document Moderation

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

Postman Collection

Field Management

Update Field Value

Postman

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

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 -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
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);
});
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

Postman

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

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 -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
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);
});
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

Postman

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

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 -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
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);
});
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

Postman

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

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 -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
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);
});
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

Postman

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

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 -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
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);
});
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

Postman

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

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 -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
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);
});
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

Postman

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

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 -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
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);
});
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

Postman

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

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 -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
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);
});
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

Postman

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

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 -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
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);
});
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

Postman

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

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 -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
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);
});
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

Postman

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

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 -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
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);
});
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

Postman

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

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 -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
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);
});
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

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 -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
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);
  }
});
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.