> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lerian.studio/llms.txt
> Use this file to discover all available pages before exploring further.
# Managing deadlines
> Track when regulatory and business reports are due with Reporter deadlines — create recurring obligations, monitor their status, and mark them delivered.
A **deadline** is Reporter's tracking layer for report deliveries. Where templates define *how* a report looks and report generation produces the *output*, a deadline records *when* a report is due and whether it has been delivered. Each deadline represents a delivery obligation — typically a regulatory filing or a recurring business report — and can optionally be tied to the template used to fulfill it.
Deadlines don't generate reports themselves. They sit alongside the [reporting lifecycle](/en/reporter/reporter-quick-start#the-reporting-lifecycle) as an operational tracker, so teams can see at a glance what's `pending`, `overdue`, or already `delivered`.
## Why deadlines exist
***
Report generation answers *how* and *what*. Deadlines answer *when* and *whether it was met*. Without a tracking layer, a team can produce perfect reports and still miss a filing window, because nothing in the reporting engine itself knows that a report was *due*.
Deadlines solve a delivery-compliance problem. They turn recurring reporting obligations into tracked, dated commitments so that nothing slips silently:
* **Regulatory reporting obligations** — many filings must reach a regulator on a fixed schedule. A deadline records that obligation, its recurrence, and its delivery state, so a missed or late filing is visible before it becomes a compliance incident.
* **Internal SLAs** — recurring business reports often carry internal commitments ("finance receives the monthly close pack by the 5th"). Deadlines make those commitments explicit and measurable.
* **Audit trails for delivery** — because each deadline records `deliveredAt` and moves through `pending` → `overdue` → `delivered`, it leaves an auditable history of *when* each obligation was satisfied, not just that a report exists.
## Who uses deadlines
***
Deadlines are a business and compliance tool layered on top of the reporting engine. Typical users include:
* A **fintech delivering regulatory reports to BACEN** on fixed monthly or annual schedules, using deadlines to guarantee each filing window is tracked and met.
* A **treasury or finance team** tracking recurring monthly report deliveries, using the calendar and status view to confirm each routine output went out on time.
* A **compliance officer** monitoring overdue obligations across the organization, filtering by `overdue` status to catch anything at risk before it escalates.
For these teams, the value isn't in producing the report — that's the reporting engine's job — but in *knowing the obligation landscape*: what's coming up, what's late, and what's done.
## How deadlines fit the Reporter workflow
***
Deadlines wrap around reports and data sources to add a **delivery status layer** on top of the reporting engine. Data Sources provide the data, Templates define the output, and the reporting lifecycle produces the file. A deadline sits above all of that: it links (optionally) to the template that fulfills the obligation, watches the due date, and exposes a single status that tells the business whether the obligation has been met.
In practice this means deadlines are *non-intrusive*. They never trigger, generate, or submit a report — they observe and record. You still generate reports through the normal lifecycle; the deadline is simply the tracker that turns that activity into a clear delivery status the rest of the organization can rely on.
## What a deadline tracks
***
Each deadline captures the due date for a report obligation plus the metadata your team needs to manage it:
| Field | Description |
| ------------------ | ------------------------------------------------------------------------------------------ |
| `name` | Human-readable name of the deadline (for example, *Monthly Regulatory Report*). |
| `description` | Optional longer description of the obligation. |
| `type` | Classification of the deadline, such as `regulatory` or `custom`. |
| `frequency` | How often the deadline recurs, such as `monthly` or `annual`. |
| `dueDate` | When the report is due, in RFC 3339 format. |
| `color` | Hex color used to visually identify the deadline in dashboards. |
| `notifyDaysBefore` | Number of days before the due date when notifications start. |
| `monthsOfYear` | Months (1–12) in which the deadline applies. |
| `templateId` | Optional UUID of the [template](/en/reporter/using-reporter) used to fulfill the deadline. |
| `active` | Whether the deadline is currently active. |
Reporter also maintains read-only fields on each deadline — `id`, `status` (`pending`, `overdue`, or `delivered`), `deliveredAt`, `templateName`, `createdAt`, and `updatedAt`.
All deadline endpoints require the `X-Organization-id` header. Include an `Authorization: Bearer ` header when [Access Manager](/en/platform/access-manager/access-manager) is enabled in your environment.
## Creating a deadline
***
Create a deadline with the [Create a Deadline](/en/reference/reporter/create-deadline) endpoint (`POST /v1/deadlines`).
The required fields are `name`, `type`, `frequency`, `dueDate`, and `color`. The remaining fields are optional — set `templateId` to link the deadline to the template that fulfills it, and `notifyDaysBefore` to control when reminders begin.
```json theme={null}
{
"name": "Monthly Regulatory Report",
"description": "Monthly regulatory compliance report",
"type": "regulatory",
"frequency": "monthly",
"dueDate": "2026-03-31T23:59:59Z",
"color": "#FF5733",
"notifyDaysBefore": 5,
"monthsOfYear": [1, 6],
"templateId": "00000000-0000-0000-0000-000000000000",
"active": true
}
```
A successful request returns `201 Created` with the full deadline, including its generated `id` and an initial `status`.
API reference: [Create a Deadline](/en/reference/reporter/create-deadline)
## Listing deadlines
***
Retrieve deadlines with the [Retrieve Deadlines](/en/reference/reporter/retrieve-deadlines) endpoint (`GET /v1/deadlines`). Results are paginated and can be filtered by status.
| Query parameter | Description | Default |
| --------------- | ----------------------------------------------- | ------- |
| `status` | Filter by `pending`, `overdue`, or `delivered`. | — |
| `limit` | Number of records per page (integer ≥ 1). | `10` |
| `page` | Page number to return (integer ≥ 1). | `1` |
For example, to list overdue deadlines, ten per page:
```
GET /v1/deadlines?status=overdue&limit=10&page=1
```
The response contains an `items` array plus `page`, `limit`, and `total` for pagination.
API reference: [Retrieve Deadlines](/en/reference/reporter/retrieve-deadlines)
## Updating a deadline
***
Update an existing deadline with the [Update a Deadline](/en/reference/reporter/update-deadline) endpoint (`PATCH /v1/deadlines/{id}`). Only the fields included in the request body are changed, so you can send a partial payload — for example, to push back a due date or deactivate a deadline:
```json theme={null}
{
"dueDate": "2026-06-30T23:59:59Z",
"notifyDaysBefore": 10,
"active": false
}
```
A successful request returns `200 OK` with the updated deadline.
API reference: [Update a Deadline](/en/reference/reporter/update-deadline)
## Deleting a deadline
***
Remove a deadline you no longer need to track with the [Delete a Deadline](/en/reference/reporter/delete-deadline) endpoint (`DELETE /v1/deadlines/{id}`). A successful request returns `204 No Content`.
API reference: [Delete a Deadline](/en/reference/reporter/delete-deadline)
## Marking a deadline as delivered
***
When the report behind a deadline has been filed or sent, mark the deadline as delivered with the [Deliver a Deadline](/en/reference/reporter/deliver-deadline) endpoint (`PATCH /v1/deadlines/{id}/deliver`). This is the action that closes the loop in the tracking workflow: it moves the deadline's `status` to `delivered` and stamps `deliveredAt`.
```json theme={null}
{
"delivered": true
}
```
Because `delivered` is a boolean, the same endpoint can also reverse the action — send `"delivered": false` to reopen a deadline that was marked delivered by mistake. A successful request returns `200 OK` with the updated deadline.
Delivering a deadline is a tracking action only. It records that the obligation was met — it does not generate or submit the underlying report. Generate the report through the [reporting lifecycle](/en/reporter/reporter-quick-start), then mark the deadline delivered to keep your tracker accurate.
API reference: [Deliver a Deadline](/en/reference/reporter/deliver-deadline)
## How deadlines fit the workflow
***
A typical obligation moves through these states:
Register the obligation with its due date, frequency, and optional template.
It shows as `pending` until the due date, then `overdue` if the report hasn't been delivered in time.
Produce the report through the normal [reporting lifecycle](/en/reporter/reporter-quick-start), using the linked template.
Call the deliver endpoint to set `status` to `delivered` and record `deliveredAt`.
## Next steps
***
Walk through the reporting lifecycle that deadlines track.
Build the templates that fulfill your deadlines.
Ready-to-use templates for Brazilian regulatory reporting.
Full request and response reference for every deadline endpoint.