---
title: "Fetch Webhook events log"
description: "URL returning webhook events log for specific document. This endpoint should be used only for missing docs research or endpoint setup debugging."
---

> Documentation Index
> Fetch the complete documentation index at: /api-docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Fetch Webhook events log

<div class="endpoint-signature"><span data-method="GET">GET</span><code>/api/webhooks/:webhook_id/logs/:document_id</code></div>

URL returning webhook events log for specific document. This endpoint should be used only for missing docs research or endpoint setup debugging.

Document payload itself has keys ordered differently than the standard document payload send to you via webhook or downloaded via api.

## Path parameters

| Name | Example | Description |
|---|---|---|
| `webhook_id` | — | — |
| `document_id` | — | — |

## Headers

| Name | Example | Description |
|---|---|---|
| `Authorization` | Bearer demo_access_token | — |

## Code examples

### cURL

```curl
curl --request GET 'https://app.datamolino.com/api/webhooks/24680/logs/98765' \
  --header 'Authorization: Bearer demo_access_token'
```
### HTTP

```http
GET /api/webhooks/24680/logs/98765 HTTP/1.1
Host: app.datamolino.com
Authorization: Bearer demo_access_token
```
### JavaScript Fetch

```javascript
const response = await fetch("https://app.datamolino.com/api/webhooks/24680/logs/98765", {
  method: "GET",
  headers: {
"Authorization": "Bearer demo_access_token"
  },
});

const data = await response.json();
```
### Node.js Axios

```javascript
import axios from "axios";

const response = await axios({
  method: "get",
  url: "https://app.datamolino.com/api/webhooks/24680/logs/98765",
  headers: {
"Authorization": "Bearer demo_access_token"
  }
});

console.log(response.data);
```
### Python Requests

```python
import requests

url = "https://app.datamolino.com/api/webhooks/24680/logs/98765"
headers = {
  "Authorization": "Bearer demo_access_token"
}

response = requests.request("GET", url, headers=headers)
response.raise_for_status()
print(response.json())
```
### Ruby Net::HTTP

```ruby
require 'json'
require 'net/http'

uri = URI("https://app.datamolino.com/api/webhooks/24680/logs/98765")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer demo_access_token"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

puts JSON.parse(response.body)
```
### Ruby on Rails

```ruby
# app/services/datamolino_client.rb
require 'json'
require 'net/http'

class DatamolinoClient
  BASE_URL = "https://app.datamolino.com"

  def initialize(access_token: Rails.application.credentials.dig(:datamolino, :access_token))
@access_token = access_token
  end

  def request_fetch_webhook_events_log
uri = URI("#{BASE_URL}/api/webhooks/24680/logs/98765")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer #{@access_token}"

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

JSON.parse(response.body)
  end
end
```
### PHP Guzzle

```php
<?php

use GuzzleHttp\Client;

$client = new Client();
$response = $client->request('GET', 'https://app.datamolino.com/api/webhooks/24680/logs/98765', [
'headers' => json_decode('{"Authorization":"Bearer demo_access_token"}', true)
]);

echo $response->getBody();
```
### Java OkHttp

```java
OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
.url("https://app.datamolino.com/api/webhooks/24680/logs/98765")
.addHeader("Authorization", "Bearer demo_access_token")
.method("GET", null)
.build();

Response response = client.newCall(request).execute();
```
### C# HttpClient

```csharp
using var client = new HttpClient();
using var request = new HttpRequestMessage(HttpMethod.Get, "https://app.datamolino.com/api/webhooks/24680/logs/98765");
request.Headers.Add("Authorization", "Bearer demo_access_token");

using var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
Console.WriteLine(await response.Content.ReadAsStringAsync());
```
### Go Native

```go
client := &http.Client{}
req, err := http.NewRequest("GET", "https://app.datamolino.com/api/webhooks/24680/logs/98765", nil)
if err != nil { panic(err) }
req.Header.Add("Authorization", "Bearer demo_access_token")

res, err := client.Do(req)
if err != nil { panic(err) }
defer res.Body.Close()

body, err := io.ReadAll(res.Body)
if err != nil { panic(err) }
fmt.Println(string(body))
```
### Swift URLSession

```swift
import Foundation

var request = URLRequest(url: URL(string: "https://app.datamolino.com/api/webhooks/24680/logs/98765")!)
request.httpMethod = "GET"
request.setValue("Bearer demo_access_token", forHTTPHeaderField: "Authorization")

let (data, _) = try await URLSession.shared.data(for: request)
print(String(data: data, encoding: .utf8)!)
```

## Responses

### 200 OK

Content type: `application/json; charset=utf-8`

```text
https://files.example.com/datamolino-demo/original/demo-supplier-invoice.pdf?expires=3600&signature=demo_signature
```

Source: /api-docs/reference/webhook/fetch-webhook-events-log/index.md