# Webhook

Webhooks allow you to receive real-time notifications of events happening within your Extracta LABS extractions. This section will guide you through setting up a Node.js server with Express to securely listen for and handle webhook events.

***

## Webhook Payload Structure

Each webhook sent by Extracta LABS will include two primary fields in the request body:

* `event` – A string identifying the type of event (e.g., `extraction.processed`, `extraction.failed`).
* `result` – A list containing files data

Example payload:

```json
{
  "event": "extraction.processed",
  "result": [
    {
      "extractionId": "extractionId",
      "batchId": "batchId",
      "fileId": "fileId",
      "fileName": "fileName",
      "status": "processed",
      "result": {},
      "url": "fileUrl"
    }
  ]
}
```

***

## See all event types

{% content-ref url="webhook-event-types" %}
[webhook-event-types](https://docs.extracta.ai/data-extraction-api/webhook-event-types)
{% endcontent-ref %}

***

## Prerequisites

* Node.js installed on your server
* An Express.js application
* A secret key obtained from the Extracta LABS dashboard

***

## Step 1: Set Up Your Server

First, ensure you have Express and the necessary packages installed in your project. If not, you can install them using npm:

```bash
npm install express body-parser crypto --save
```

***

## Step 2: Implement Webhook Endpoint

Create a basic HTTP server with Express to listen for webhook POST requests. Use the following code snippet as a starting point:

{% code title="server.js" fullWidth="false" %}

```javascript
const express = require('express');
const crypto = require('crypto');
const bodyParser = require('body-parser');

const app = express();
const port = 4000;

app.use(bodyParser.json());

// Your webhook secret key from the dashboard
const secret = 'secretKey';

// Middleware to validate the webhook signature
function validateSignature(req, res, next) {
    const signatureRequest = req.headers["x-webhook-signature"];

    const resultString = JSON.stringify(req.body.result);
    const signature = crypto.createHmac('sha256', secret.replace('E_AI_K_', '')).update(resultString).digest('base64');

    if (signature !== signatureRequest) {
        return res.status(401).send({
            message: "Webhook is not properly signed"
        });
    }

    return next();
}

// Webhook endpoint
app.post('/webhook', validateSignature, async (req, res) => {
    try {
        let { event, result } = req.body;

        switch (event) {
            case "extraction.processed":
                console.log("extraction.processed", result);
                break;
            case "extraction.edited":
                console.log("extraction.edited", result);
                break;
            case "extraction.confirmed":
                console.log("extraction.confirmed", result);
                break;
            case "extraction.failed":
                console.log("extraction.failed", result);
                break;
            default:
                console.log("unknown event", event);
                break;
        }

        return res.send({
            event: event,
            message: "Webhook received",
            timestamp: new Date().toISOString()
        })
    } catch (error) {
        console.error("Error processing webhook", error);

        return res.status(500).send({
            message: "Error processing webhook",
            error: error.message,
            timestamp: new Date().toISOString()
        });
    }
})

app.listen(port, () => console.log(`Server listening on port ${port}!`))
```

{% endcode %}

***

## Step 3: Test Your Webhook Listener

Once your webhook listener is set up, test it by triggering events from Extracta LABS. Confirm that:

* The signature is validated correctly.
* The `event` is identified.
* The `result` is handled based on the event type.

***

By following these steps, you can securely set up your application to receive and process webhook events from Extracta LABS, enabling real-time updates and actions based on the events transmitted to your endpoint.