# API monitoring endpoints

Source: https://docs.settlemint.com/docs/developer-guides/api-integration/api-monitoring
Query API traffic, latency, errors, request logs, and real-time API activity from the DALP monitoring API.



## Overview [#overview]

The API monitoring endpoints let administrators inspect recent DALP API traffic for their organization. Use them to answer operational questions such as which endpoints are busiest, which requests are failing, how latency changes over time, and what happened during a specific API request.

Use these endpoints for operational monitoring and troubleshooting. Responses include tenant-scoped API metrics and request-log data for authenticated administrators or organization owners.

## Requirements [#requirements]

Before calling these endpoints:

* Authenticate with a DALP account that has administrator access for the active organization.
* Send timestamps as ISO 8601 values.
* Keep request ranges inside the endpoint-specific range limit.
* Use the API reference for generated client method names and exact transport details.

## Endpoint summary [#endpoint-summary]

| Purpose             | Method and path                                         | Range limit | Use it for                                                                              |
| ------------------- | ------------------------------------------------------- | ----------- | --------------------------------------------------------------------------------------- |
| Summary metrics     | `GET /api/v2/monitoring/api/request-metrics/summary`    | 7 days      | Total request volume, error rate, 4xx and 5xx counts, average latency, and p95 latency. |
| Timeline            | `GET /api/v2/monitoring/api/request-metrics/timeline`   | 31 days     | Hourly or daily buckets split by REST/RPC traffic and status class.                     |
| Endpoint metrics    | `GET /api/v2/monitoring/api/endpoint-metrics`           | 7 days      | Per-endpoint request count, latency, error rate, filters, sorting, and pagination.      |
| Request logs        | `GET /api/v2/monitoring/api/request-logs`               | 7 days      | Paginated request-log rows with filters and facets.                                     |
| Request log detail  | `GET /api/v2/monitoring/api/request-logs/{id}`          | N/A         | One log entry with redacted request and response detail.                                |
| Top errors          | `GET /api/v2/monitoring/api/request-metrics/top-errors` | 30 days     | Endpoints with the highest error counts and their dominant error status code.           |
| Live request stream | `GET /api/v2/monitoring/api/request-logs/stream`        | N/A         | Server-sent events for new API request-log entries in the active organization.          |

## Get summary metrics [#get-summary-metrics]

Use the summary endpoint when you need a compact health snapshot for a time range.

```bash
curl -G "$DALP_API_URL/api/v2/monitoring/api/request-metrics/summary" \
  --header "X-Api-Key: ${DALP_API_TOKEN}" \
  --data-urlencode "from=2026-05-15T00:00:00.000Z" \
  --data-urlencode "to=2026-05-15T12:00:00.000Z" \
  --data-urlencode "requestType=rest"
```

The response includes:

* `totalRequests`
* `errorRate`, expressed as a fraction from `0` to `1`
* `serverErrorRate` for 5xx responses, when present
* `clientErrorRate` for 4xx responses, when present
* `avgDurationMs`
* `p95DurationMs`, which can be `null`
* `error4xxCount`
* `error5xxCount`

## Build a traffic timeline [#build-a-traffic-timeline]

Use the timeline endpoint to chart API activity over time. Set `granularity` to `hour` or `day`. You can also pass `endpointId` when you want the timeline for one endpoint.

```bash
curl -G "$DALP_API_URL/api/v2/monitoring/api/request-metrics/timeline" \
  --header "X-Api-Key: ${DALP_API_TOKEN}" \
  --data-urlencode "from=2026-05-01T00:00:00.000Z" \
  --data-urlencode "to=2026-05-08T00:00:00.000Z" \
  --data-urlencode "granularity=day"
```

Each bucket returns a timestamp, REST and RPC success counts, REST and RPC 4xx counts, REST and RPC 5xx counts, and average duration in milliseconds.

## Find slow or erroring endpoints [#find-slow-or-erroring-endpoints]

Use endpoint metrics when you need a ranked list of route templates.

```bash
curl -G "$DALP_API_URL/api/v2/monitoring/api/endpoint-metrics" \
  --header "X-Api-Key: ${DALP_API_TOKEN}" \
  --data-urlencode "from=2026-05-15T00:00:00.000Z" \
  --data-urlencode "to=2026-05-15T12:00:00.000Z" \
  --data-urlencode "orderBy=errorRate" \
  --data-urlencode "limit=20"
```

Supported filters include `method`, `endpoint`, `tag`, and `requestType`. Supported sort fields are `requestCount`, `avgDurationMs`, and `errorRate`. The response includes `items`, `totalCount`, and server-computed `facets` for filterable columns.

## Review request logs [#review-request-logs]

Use request logs to inspect individual API calls. Logs support keyset pagination through `cursor` and return `nextCursor` when more rows are available.

```bash
curl -G "$DALP_API_URL/api/v2/monitoring/api/request-logs" \
  --header "X-Api-Key: ${DALP_API_TOKEN}" \
  --data-urlencode "from=2026-05-15T00:00:00.000Z" \
  --data-urlencode "to=2026-05-15T12:00:00.000Z" \
  --data-urlencode "statusClass=5xx" \
  --data-urlencode "limit=50"
```

Supported filters include:

* `endpointId`
* `statusCode`
* `statusClass`: `2xx`, `4xx`, or `5xx`
* `endpoint`, matched against the route template
* `method`
* `requestType`: `rest` or `rpc`
* `cursor`
* `limit`, from 1 to 100

Each log row includes method, route template, request type, status code, duration, request time, caller information, IP address, user agent, trace ID, and idempotency key when available.

## Open a request log detail [#open-a-request-log-detail]

Use the detail endpoint after selecting a log row. The response includes the same core log fields plus request and response sizes, a short error message, redacted headers and bodies, request URL, structured error details, trace ID, and idempotency key.

```bash
curl "$DALP_API_URL/api/v2/monitoring/api/request-logs/$LOG_ID" \
  --header "X-Api-Key: ${DALP_API_TOKEN}"
```

If the log entry is not visible in the active organization, the API returns a not-found error.

## Identify top erroring endpoints [#identify-top-erroring-endpoints]

Use top errors to prioritize investigation by endpoint. The endpoint ranks routes by error count and returns total count, error count, error rate, and the dominant status code for each route.

```bash
curl -G "$DALP_API_URL/api/v2/monitoring/api/request-metrics/top-errors" \
  --header "X-Api-Key: ${DALP_API_TOKEN}" \
  --data-urlencode "from=2026-05-01T00:00:00.000Z" \
  --data-urlencode "to=2026-05-15T00:00:00.000Z" \
  --data-urlencode "limit=5"
```

The optional `requestType` filter narrows the result to REST or RPC traffic. `limit` can be from 1 to 20.

## Stream new request logs [#stream-new-request-logs]

Use the stream endpoint when you need live activity in an operations console. The server-sent event stream yields one log entry for each new captured API request in the active organization.

```bash
curl -N "$DALP_API_URL/api/v2/monitoring/api/request-logs/stream" \
  --header "X-Api-Key: ${DALP_API_TOKEN}"
```

The stream does not accept filters. Apply filtering in the client if you only want to show specific methods, endpoints, request types, or status classes.

## Operational notes [#operational-notes]

* `from` is inclusive and `to` is exclusive.
* Summary, endpoint metrics, and request logs accept a maximum 7-day range.
* Top errors accepts a maximum 30-day range.
* Timeline accepts a maximum 31-day range.
* `errorRate` values are fractions. Multiply by 100 when displaying percentages.
* Request and response bodies in log detail are redacted before they are returned.
* Log and metric data is scoped to the active organization.

## Related guides [#related-guides]

* [API reference](/docs/developer-guides/api-integration/api-reference) for the generated OpenAPI specification.
* [Error handling](/docs/developer-guides/api-integration/error-handling) for retry and failure-handling patterns.
* [Blockchain monitoring](/docs/developer-guides/operations/blockchain-monitoring) for chain and transaction monitoring workflows.
