{
  "info": {
    "name": "Scanverion AI API v1",
    "description": "Focused AI integration workflow generated from docs/openapi/v1.json. Import the Scanverion Local environment, set apiKey and sample-file paths, then run 00 - Setup in order. API keys are server-side secrets.",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
  },
  "variable": [
    {
      "key": "baseUrl",
      "value": "http://localhost:5009"
    },
    {
      "key": "apiKey",
      "value": ""
    },
    {
      "key": "sampleDocument",
      "value": "C:/path/to/invoice.pdf"
    },
    {
      "key": "sampleDocument2",
      "value": "C:/path/to/receipt.jpg"
    },
    {
      "key": "sampleVehicle",
      "value": "C:/path/to/vehicle.jpg"
    },
    {
      "key": "fromDate",
      "value": "2026-08-01"
    },
    {
      "key": "toDate",
      "value": "2026-08-31"
    }
  ],
  "item": [
    {
      "name": "00 - Setup",
      "item": [
        {
          "name": "Test API key and list capabilities",
          "request": {
            "description": "Verify the API key and inspect supported models, operations, MIME types, and file limits.",
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              },
              {
                "key": "Authorization",
                "value": "Bearer {{apiKey}}"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/ai/capabilities",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "ai",
                "capabilities"
              ]
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        },
        {
          "name": "Check API health",
          "request": {
            "description": "Confirm that the configured baseUrl is reachable. No API key is required.",
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/health",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "health"
              ]
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        }
      ]
    },
    {
      "name": "01 - Document AI",
      "item": [
        {
          "name": "Process one document",
          "request": {
            "description": "Upload one JPEG, PNG, WebP, or PDF and run Detection and Scanner. The API automatically uses full-page OCR when page-level evidence identifies an invoice; change repeated Operations fields for other document capabilities.",
            "method": "POST",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              },
              {
                "key": "Authorization",
                "value": "Bearer {{apiKey}}"
              },
              {
                "key": "Idempotency-Key",
                "value": "postman-{{$guid}}",
                "description": "Required for safe automatic retries of processing POST requests."
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/ai/document-processing",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "ai",
                "document-processing"
              ]
            },
            "body": {
              "mode": "formdata",
              "formdata": [
                {
                  "key": "File",
                  "type": "file",
                  "src": "{{sampleDocument}}"
                },
                {
                  "key": "Operations",
                  "value": "Detection",
                  "type": "text"
                },
                {
                  "key": "Operations",
                  "value": "Scanner",
                  "type": "text"
                }
              ]
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        },
        {
          "name": "Process a document batch",
          "request": {
            "description": "Upload two or more documents using repeated Files fields and receive one grouped batch response.",
            "method": "POST",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              },
              {
                "key": "Authorization",
                "value": "Bearer {{apiKey}}"
              },
              {
                "key": "Idempotency-Key",
                "value": "postman-{{$guid}}",
                "description": "Required for safe automatic retries of processing POST requests."
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/ai/document-processing/batches",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "ai",
                "document-processing",
                "batches"
              ]
            },
            "body": {
              "mode": "formdata",
              "formdata": [
                {
                  "key": "Files",
                  "type": "file",
                  "src": "{{sampleDocument}}"
                },
                {
                  "key": "Files",
                  "type": "file",
                  "src": "{{sampleDocument2}}"
                },
                {
                  "key": "Operations",
                  "value": "Detection",
                  "type": "text"
                },
                {
                  "key": "Operations",
                  "value": "Scanner",
                  "type": "text"
                }
              ]
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        }
      ]
    },
    {
      "name": "02 - Vehicle AI",
      "item": [
        {
          "name": "Process one vehicle image",
          "request": {
            "description": "Upload one vehicle image. Vehicle processing supports Detection and Blur.",
            "method": "POST",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              },
              {
                "key": "Authorization",
                "value": "Bearer {{apiKey}}"
              },
              {
                "key": "Idempotency-Key",
                "value": "postman-{{$guid}}",
                "description": "Required for safe automatic retries of processing POST requests."
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/ai/vehicle-processing",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "ai",
                "vehicle-processing"
              ]
            },
            "body": {
              "mode": "formdata",
              "formdata": [
                {
                  "key": "File",
                  "type": "file",
                  "src": "{{sampleVehicle}}"
                },
                {
                  "key": "Operations",
                  "value": "Detection",
                  "type": "text"
                }
              ]
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        },
        {
          "name": "Process a vehicle batch",
          "request": {
            "description": "Upload multiple vehicle images using repeated Files fields.",
            "method": "POST",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              },
              {
                "key": "Authorization",
                "value": "Bearer {{apiKey}}"
              },
              {
                "key": "Idempotency-Key",
                "value": "postman-{{$guid}}",
                "description": "Required for safe automatic retries of processing POST requests."
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/ai/vehicle-processing/batches",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "ai",
                "vehicle-processing",
                "batches"
              ]
            },
            "body": {
              "mode": "formdata",
              "formdata": [
                {
                  "key": "Files",
                  "type": "file",
                  "src": "{{sampleVehicle}}"
                },
                {
                  "key": "Files",
                  "type": "file",
                  "src": "{{sampleVehicle}}"
                },
                {
                  "key": "Operations",
                  "value": "Detection",
                  "type": "text"
                }
              ]
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        }
      ]
    },
    {
      "name": "03 - Validation",
      "item": [
        {
          "name": "Check a lost or stolen ID",
          "request": {
            "description": "Check a supported Slovak identity-document number against the authority-backed validation resource.",
            "method": "POST",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              },
              {
                "key": "Authorization",
                "value": "Bearer {{apiKey}}"
              },
              {
                "key": "Content-Type",
                "value": "application/json"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/validation/id-cards/lost-or-stolen",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "validation",
                "id-cards",
                "lost-or-stolen"
              ]
            },
            "body": {
              "mode": "raw",
              "raw": "{\n  \"cardNumber\": \"AA123456\",\n  \"cardType\": \"nationalId\"\n}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        },
        {
          "name": "Look up a postal code",
          "request": {
            "description": "Resolve a Slovak address using address and countryCode query variables.",
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              },
              {
                "key": "Authorization",
                "value": "Bearer {{apiKey}}"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/validation/postal-codes?address=Pribinova%2010%2C%20Bratislava&countryCode=SK",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "validation",
                "postal-codes"
              ],
              "query": [
                {
                  "key": "address",
                  "value": "Pribinova 10, Bratislava"
                },
                {
                  "key": "countryCode",
                  "value": "SK"
                }
              ]
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        }
      ]
    },
    {
      "name": "04 - Usage",
      "item": [
        {
          "name": "Get usage summary",
          "request": {
            "description": "Return calls, credits, and estimated cost for the configured inclusive date range.",
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              },
              {
                "key": "Authorization",
                "value": "Bearer {{apiKey}}"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/usage/summary?From={{fromDate}}&To={{toDate}}",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "usage",
                "summary"
              ],
              "query": [
                {
                  "key": "From",
                  "value": "{{fromDate}}"
                },
                {
                  "key": "To",
                  "value": "{{toDate}}"
                }
              ]
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        },
        {
          "name": "Get daily usage",
          "request": {
            "description": "Return daily usage points for the configured inclusive date range.",
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              },
              {
                "key": "Authorization",
                "value": "Bearer {{apiKey}}"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/usage/daily?From={{fromDate}}&To={{toDate}}",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "usage",
                "daily"
              ],
              "query": [
                {
                  "key": "From",
                  "value": "{{fromDate}}"
                },
                {
                  "key": "To",
                  "value": "{{toDate}}"
                }
              ]
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        },
        {
          "name": "Get usage by capability",
          "request": {
            "description": "Group calls and credits by charged capability for the configured date range.",
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              },
              {
                "key": "Authorization",
                "value": "Bearer {{apiKey}}"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/usage/by-capability?From={{fromDate}}&To={{toDate}}",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "usage",
                "by-capability"
              ],
              "query": [
                {
                  "key": "From",
                  "value": "{{fromDate}}"
                },
                {
                  "key": "To",
                  "value": "{{toDate}}"
                }
              ]
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        },
        {
          "name": "Preview usage price",
          "request": {
            "description": "Preview included and overage cost for the configured date range.",
            "method": "GET",
            "header": [
              {
                "key": "Accept",
                "value": "application/json"
              },
              {
                "key": "Authorization",
                "value": "Bearer {{apiKey}}"
              }
            ],
            "url": {
              "raw": "{{baseUrl}}/api/v1/usage/price-preview?From={{fromDate}}&To={{toDate}}",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "v1",
                "usage",
                "price-preview"
              ],
              "query": [
                {
                  "key": "From",
                  "value": "{{fromDate}}"
                },
                {
                  "key": "To",
                  "value": "{{toDate}}"
                }
              ]
            }
          },
          "response": [],
          "event": [
            {
              "listen": "test",
              "script": {
                "exec": [
                  "pm.test('Request succeeded', () => pm.expect(pm.response.code).to.be.within(200, 299));",
                  "pm.test('Response is JSON', () => pm.response.to.be.json);",
                  "const requestId = pm.response.headers.get('X-Request-Id') || pm.response.json().requestId;",
                  "if (requestId) pm.collectionVariables.set('lastRequestId', requestId);"
                ]
              }
            }
          ]
        }
      ]
    }
  ]
}