# 2. View classification

<mark style="color:green;">`POST`</mark> `/documentClassification/viewClassification`

This endpoint retrieves the details of a classification process previously defined in the system. By submitting the unique classificationId, you can obtain information such as the classification name, description, configured document types, associated keywords, and any linked extraction templates. This is useful for verifying your classification setup or for debugging and auditing purposes.

## Server URL

```
https://api.extracta.ai/api/v1
```

## Headers

| Name          | Value              |
| ------------- | ------------------ |
| Content-Type  | `application/json` |
| Authorization | `Bearer <token>`   |

## Body

<table><thead><tr><th width="218">Name</th><th width="126">Type</th><th width="115">Required</th><th>Description</th></tr></thead><tbody><tr><td><code>classificationId</code></td><td>string</td><td><code>true</code></td><td>Unique identifier for the classification.</td></tr></tbody></table>

## Body Example

```json
{
    "classificationId": "classificationId"
}
```

## Code Example

{% tabs %}
{% tab title="JavaScript" %}

```javascript
const axios = require('axios');

async function viewClassification(token, classificationId) {
    const url = "https://api.extracta.ai/api/v1/documentClassification/viewClassification";

    try {
        const response = await axios.post(url, {
            classificationId: classificationId
        }, {
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${token}`
            }
        });

        return response.data;
    } catch (error) {
        throw error.response ? error.response.data : new Error('An unknown error occurred');
    }
}

async function main() {
    const token = 'apiKey';
    const classificationId = 'classificationId';

    try {
        const classificationDetails = await viewClassification(token, classificationId);
        console.log("Classification Details:", classificationDetails);
    } catch (error) {
        console.error("Failed to retrieve classification details:", error);
    }
}

main();
```

{% endtab %}

{% tab title="Python" %}

```python
import requests

def view_classification(token, classification_id):   
    url = "https://api.extracta.ai/api/v1/documentClassification/viewClassification"
    
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {token}'
    }
    
    payload = {
        'classificationId': classification_id
    }

    try:
        response = requests.post(url, json=payload, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.RequestException as e:
        print(f"Failed to retrieve classification details: {e}")
        return None

# Example usage
if __name__ == "__main__":
    token = 'apiKey'
    classification_id = 'classificationId'

    classification_details = view_classification(token, classification_id)
    if classification_details is not None:
        print("Classification Details:", classification_details)

```

{% endtab %}

{% tab title="PHP" %}

```php
<?php

function viewClassification($token, $classificationId) {
    $url = 'https://api.extracta.ai/api/v1/documentClassification/viewClassification';

    // Initialize cURL session
    $ch = curl_init($url);

    // Prepare the payload
    $payload = json_encode(['classificationId' => $classificationId]);

    // Set cURL options
    curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Content-Type: application/json',
        'Authorization: Bearer ' . $token
    ]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, 1);

    try {
        // Execute cURL session
        $response = curl_exec($ch);

        // Check for cURL errors
        if (curl_errno($ch)) {
            throw new Exception('Curl error: ' . curl_error($ch));
        }

        // return the response as an associative array
        return json_decode($response, true);
    } catch (Exception $e) {
        return 'Error: ' . $e->getMessage();
    } finally {
        curl_close($ch);
    }
}

// Example usage
$token = 'apiKey';
$classificationId = 'classificationId';

try {
    $classificationDetails = viewClassification($token, $classificationId);
    print_r($classificationDetails);
} catch (Exception $e) {
    echo "Failed to retrieve classification details: " . $e->getMessage();
}

?>

```

{% endtab %}
{% endtabs %}

## Responses

{% tabs %}
{% tab title="200" %}

```json
{
    "status": "success",
    "classificationId": "-OPkce8E1CuEQeHDZetx",
    "classificationDetails": {
        "createdAt": 1746720170530,
        "name": "Financial Document Classifier"
        "description": "Classifies uploaded documents into predefined financial document types.",
        "documentTypes": [
            {
                "description": "Standard commercial invoice from vendors or suppliers.",
                "extractionId": "-OPXR1F82I0cRYJPcHNo",
                "name": "Invoice",
                "uniqueWords": [
                    "invoice number",
                    "bill to",
                    "total amount"
                ]
            },
            {
                "description": "Internal or external purchase order documents.",
                "name": "Purchase Order",
                "uniqueWords": [
                    "PO number",
                    "item description",
                    "quantity ordered"
                ]
            },
            {
                "description": "Retail or online transaction receipts.",
                "name": "Receipt",
                "uniqueWords": [
                    "receipt",
                    "paid",
                    "transaction id"
                ]
            }
        ]
    }
}
```

{% endtab %}

{% tab title="400" %}

```json
{
    "status": "error",
    "message": "Classification does not exist"
}
```

{% endtab %}

{% tab title="500" %}

```json
{
    "status": "error",
    "message": "Error viewing classification"
}
```

{% endtab %}
{% endtabs %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.extracta.ai/document-classification-api/api-endpoints-document-classification/2.-view-classification.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.