---
title: Check recent event ingestion
description: "Checks whether events reached an Amplitude project during a recent time window. Provide event type to check one exact event type, or omit it to check for any…"
product: general
token_estimate: 2654
---
# Check recent event ingestion

> For AI agents: a documentation index is available at [/docs/llms.txt](/docs/llms.txt). Append `.md` to any page URL for markdown, or send `Accept: text/markdown`.

## Check recent event ingestion

**POST** `/v1/projects/{project_id}/events/check-recent-ingestion`

Full URL: `https://developer-api.amplitude.com/v1/projects/{project_id}/events/check-recent-ingestion`

**Servers:**
- Production: `https://developer-api.amplitude.com/v1/projects/{project_id}/events/check-recent-ingestion`
- Staging: `https://developer-api.stag2.amplitude.com/v1/projects/{project_id}/events/check-recent-ingestion`

Check recent event ingestion

Checks whether events reached an Amplitude project during a recent time
window. Provide `event_type` to check one exact event type, or omit it to
check for any event. The default lookback is 10 minutes. The returned
window can begin up to five minutes earlier so the evaluation covers the
complete starting interval.

`observed` means at least one matching event was found. `not_observed`
means no matching event was found in the evaluated window. `inconclusive`
means no matching event was found, but complete recent data was not
available to confirm its absence. Use the returned window when reporting
or comparing results.

This POST computes a result and does not mutate state, so it does not
require an `Idempotency-Key`.

Provide `polling_timeout_seconds` to request server polling guidance.
While another check is advised, successful responses include
`poll_after_seconds`; its omission means clients should stop polling.

## Authorizations

| Name | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| Authorization | string | Yes | — | http |

## Path parameters

| Name | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| project_id (path) | string | Yes | 12345 | Amplitude project identifier, backed by the canonical app ID. Constraints: pattern: ^[0-9]+$ |

## Body (application/json)

| Name | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| event_type | string | No | — | Exact event type to check. Omit to check for any event. Constraints: pattern: \S |
| lookback_minutes | integer | No | 10 | Number of recent minutes to evaluate. The returned window can begin up to five minutes earlier to cover the complete starting interval. Constraints: min: 1, max: 1440 |
| polling_timeout_seconds | integer | No | — | Maximum polling window requested by the caller. Clients should complete the initial check even if it exceeds this window and use the window only to limit subsequent polls. Its presence requests polling guidance; it is not an HTTP request timeout, and each HTTP request performs one check. Constraints: min: 1, max: 120 |

## Response (application/json)

**200** — Ingestion check completed successfully.

| Name | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| data | object | Yes | — | — |
| data.id | string | Yes | — | Identifier for this ingestion check. |
| data.object | string | Yes | — | Resource-type discriminator. Always `recent_event_ingestion_check`. |
| data.project_id | string | Yes | — | Constraints: pattern: ^[0-9]+$ |
| data.event_type | string | No | — | Event type evaluated. Omitted when the request checked for any event. |
| data.status | string | Yes | — | `observed` when at least one matching event was found; `not_observed` when none was found; `inconclusive` when none was found but complete recent data was unavailable. Allowed values: observed, not_observed, inconclusive |
| data.count | number | Yes | — | Number of matching events found in the evaluated window. Constraints: min: 0 |
| data.poll_after_seconds | integer | No | — | Minimum seconds to wait before the next ingestion check. Returned only when polling was requested and another check is advised. Its omission means the server does not advise another check. Constraints: min: 1 |
| data.window | object | Yes | — | — |
| data.window.start | string | Yes | — | Start of the evaluated window. Constraints: format: date-time |
| data.window.end | string | Yes | — | End of the evaluated window. Constraints: format: date-time |
| data.window.basis | string | Yes | — | Time basis for the window. `server_upload_time` measures when an event reached Amplitude. |

```json
{
  "data": {
    "id": "string",
    "object": "recent_event_ingestion_check",
    "project_id": "string",
    "event_type": "string",
    "status": "observed",
    "count": 0,
    "poll_after_seconds": 1,
    "window": {
      "start": "2024-01-01T00:00:00Z",
      "end": "2024-01-01T00:00:00Z",
      "basis": "server_upload_time"
    }
  }
}
```

**400**

**401**

**403** — The caller cannot use this operation. `operation_not_enabled` means the
operation is not enabled for the caller's organization;
`insufficient_scope` means the token lacks `analytics:read`.


| Name | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| type | string | Yes | — | Constraints: format: uri |
| title | string | Yes | — | — |
| status | integer | Yes | — | Constraints: min: 400, max: 599 |
| detail | string | No | — | Constraints: nullable |
| instance | string | No | — | Constraints: format: uri, nullable |
| error_code | string | Yes | — | — |
| retryable | boolean | Yes | — | — |
| retry_after_seconds | integer | No | — | Constraints: nullable, min: 0 |
| validation_errors | object[] | No | — | Constraints: nullable |

```json
{
  "type": "https://developer-api.amplitude.com/problems/operation-not-enabled",
  "title": "The caller cannot use this operation. `operation_not_enabled` means the\noperation is not enabled for the caller's organization;\n`insufficient_scope` means the token lacks `analytics:read`.\n",
  "status": 403,
  "detail": "This endpoint is unavailable for your organization.",
  "error_code": "operation_not_enabled",
  "retryable": false
}
```

**404**

**429**

**500**

**502** — The ingestion status could not be determined. Retryable responses use
`event_type_not_queryable`, `unreliable_dataset_response`, or
`upstream_error` as the `error_code`.


| Name | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| type | string | Yes | — | Constraints: format: uri |
| title | string | Yes | — | — |
| status | integer | Yes | — | Constraints: min: 400, max: 599 |
| detail | string | No | — | Constraints: nullable |
| instance | string | No | — | Constraints: format: uri, nullable |
| error_code | string | Yes | — | — |
| retryable | boolean | Yes | — | — |
| retry_after_seconds | integer | No | — | Constraints: nullable, min: 0 |
| validation_errors | object[] | No | — | Constraints: nullable |

```json
{
  "type": "https://example.com",
  "title": "The ingestion status could not be determined. Retryable responses use\n`event_type_not_queryable`, `unreliable_dataset_response`, or\n`upstream_error` as the `error_code`.\n",
  "status": 502,
  "detail": "string",
  "instance": "https://example.com",
  "error_code": "string",
  "retryable": true,
  "retry_after_seconds": 0,
  "validation_errors": [
    {
      "field": "string",
      "message": "string",
      "code": "string"
    }
  ]
}
```

**503** — Endpoint not available.

| Name | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| type | string | Yes | — | Constraints: format: uri |
| title | string | Yes | — | — |
| status | integer | Yes | — | Constraints: min: 400, max: 599 |
| detail | string | No | — | Constraints: nullable |
| instance | string | No | — | Constraints: format: uri, nullable |
| error_code | string | Yes | — | — |
| retryable | boolean | Yes | — | — |
| retry_after_seconds | integer | No | — | Constraints: nullable, min: 0 |
| validation_errors | object[] | No | — | Constraints: nullable |

```json
{
  "type": "https://developer-api.amplitude.com/problems/operation-availability-unavailable",
  "title": "Endpoint not available.",
  "status": 503,
  "detail": "This endpoint is not available.",
  "error_code": "operation_availability_unavailable",
  "retryable": true
}
```

## Code samples

### cURL

```bash
curl -X POST "https://developer-api.amplitude.com/v1/projects/12345/events/check-recent-ingestion" \
  -H "Content-Type: application/json" \
  -H "Authorization: YOUR_API_KEY"
```

### Python

```python
import requests

response = requests.post(
    "https://developer-api.amplitude.com/v1/projects/12345/events/check-recent-ingestion",
    headers={
        "Content-Type": "application/json",
        "Authorization": "YOUR_API_KEY"
    }
)
data = response.json()
```

### JavaScript

```javascript
const response = await fetch("https://developer-api.amplitude.com/v1/projects/12345/events/check-recent-ingestion", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "YOUR_API_KEY"
  }
});
const data = await response.json();
```

### PHP

```php
<?php
$ch = curl_init("https://developer-api.amplitude.com/v1/projects/12345/events/check-recent-ingestion");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Content-Type: application/json",
    "Authorization: YOUR_API_KEY"
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
```

### Go

```go
package main

import (
  "bytes"
  "net/http"
)

func main() {
req, _ := http.NewRequest("POST", "https://developer-api.amplitude.com/v1/projects/12345/events/check-recent-ingestion", nil)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "YOUR_API_KEY")
  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()
}
```

### Java

```java
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://developer-api.amplitude.com/v1/projects/12345/events/check-recent-ingestion"))
      .method("POST", HttpRequest.BodyPublishers.noBody())
.header("Content-Type", "application/json")
      .header("Authorization", "YOUR_API_KEY")
      .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
```

### Ruby

```ruby
require "net/http"
require "json"

uri = URI("https://developer-api.amplitude.com/v1/projects/12345/events/check-recent-ingestion")
request = Net::HTTP::Post.new(uri)
request["Content-Type"] = "application/json"
request["Authorization"] = "YOUR_API_KEY"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end
```