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

# Business Processing Reporting

> Business Processing Reporting in Vantage captures transaction-level data, skill versions, step timings, and reviewer details for auditing and analysis.

export const VantageRegion = ({children}) => {
  const STORAGE_KEY = "abbyy.vantage.region";
  const REGIONS = [{
    code: "eu",
    label: "Europe"
  }, {
    code: "us",
    label: "North America"
  }, {
    code: "au",
    label: "Australia / Asia-Pacific"
  }];
  const [region, setRegion] = useState("eu");
  const [open, setOpen] = useState(false);
  const containerRef = useRef(null);
  const dropdownRef = useRef(null);
  function safeGetSavedRegion() {
    try {
      const saved = typeof window !== "undefined" ? window.localStorage.getItem(STORAGE_KEY) : null;
      const valid = new Set(REGIONS.map(r => r.code));
      return saved && valid.has(saved) ? saved : "eu";
    } catch {
      return "eu";
    }
  }
  function safeSetSavedRegion(code) {
    try {
      if (typeof window !== "undefined") {
        window.localStorage.setItem(STORAGE_KEY, code);
      }
    } catch {}
  }
  function dispatchRegionChanged(code) {
    try {
      if (typeof window !== "undefined") {
        window.dispatchEvent(new CustomEvent("abbyy:region-changed", {
          detail: {
            code
          }
        }));
      }
    } catch {}
  }
  function replaceRegionInString(text, currentRegion) {
    if (typeof text !== "string") return text;
    const hostRegex = /https:\/\/vantage-(eu|us|au)\.abbyy\.com/gi;
    const tokenRegex = /https:\/\/vantage-\[region\]\.abbyy\.com/gi;
    const bareHostRegex = /vantage-(eu|us|au)\.abbyy\.com/gi;
    const bareTokenRegex = /vantage-\[region\]\.abbyy\.com/gi;
    return text.replace(hostRegex, `https://vantage-${currentRegion}.abbyy.com`).replace(tokenRegex, `https://vantage-${currentRegion}.abbyy.com`).replace(bareHostRegex, `vantage-${currentRegion}.abbyy.com`).replace(bareTokenRegex, `vantage-${currentRegion}.abbyy.com`);
  }
  useEffect(() => {
    setRegion(safeGetSavedRegion());
  }, []);
  useEffect(() => {
    const root = containerRef.current;
    if (!root) return;
    const anchors = root.querySelectorAll("a[href]");
    anchors.forEach(a => {
      const href = a.getAttribute("href");
      if (href) {
        const next = replaceRegionInString(href, region);
        if (next !== href) {
          a.setAttribute("href", next);
        }
      }
    });
    const walker = typeof document !== "undefined" ? document.createTreeWalker(root, NodeFilter.SHOW_TEXT, null) : null;
    if (walker) {
      const toUpdate = [];
      let node = walker.nextNode();
      while (node) {
        const updated = replaceRegionInString(node.nodeValue, region);
        if (updated !== node.nodeValue) {
          toUpdate.push([node, updated]);
        }
        node = walker.nextNode();
      }
      toUpdate.forEach(([textNode, value]) => {
        textNode.nodeValue = value;
      });
    }
  }, [region, children]);
  useEffect(() => {
    const root = containerRef.current;
    if (!root) return;
    const anchors = root.querySelectorAll("a[href]");
    anchors.forEach(a => {
      a.style.fontWeight = "600";
      a.style.textDecoration = "underline";
      a.style.textUnderlineOffset = "2px";
    });
  }, [region, children]);
  useEffect(() => {
    const onRegionChanged = evt => {
      const code = evt && evt.detail && evt.detail.code;
      if (!code || code === region) return;
      setRegion(code);
    };
    if (typeof window !== "undefined") {
      window.addEventListener("abbyy:region-changed", onRegionChanged);
    }
    return () => {
      if (typeof window !== "undefined") {
        window.removeEventListener("abbyy:region-changed", onRegionChanged);
      }
    };
  }, [region]);
  useEffect(() => {
    const onClickAway = e => {
      if (!dropdownRef.current) return;
      if (!dropdownRef.current.contains(e.target)) {
        setOpen(false);
      }
    };
    document.addEventListener("click", onClickAway, true);
    return () => document.removeEventListener("click", onClickAway, true);
  }, []);
  const onSelect = code => {
    setRegion(code);
    safeSetSavedRegion(code);
    dispatchRegionChanged(code);
    setOpen(false);
  };
  const current = REGIONS.find(r => r.code === region) || REGIONS[0];
  return <div className="not-prose">
      <div className="mb-4 inline-flex items-center gap-2" ref={dropdownRef}>
        <span className="text-sm text-zinc-950/80 dark:text-white/80">Tenant Region:</span>
        <div className="relative">
          <button type="button" aria-haspopup="listbox" aria-expanded={open ? "true" : "false"} onClick={() => setOpen(v => !v)} className="h-8 px-3 rounded-md bg-zinc-900/5 dark:bg-white/5 border border-zinc-950/20 dark:border-white/20 text-sm inline-flex items-center gap-2">
            <span className="text-zinc-950 dark:text-white">{current.label}</span>
            <svg width="8" height="24" viewBox="0 -9 3 24" className="transition-transform text-gray-400 overflow-visible dark:text-gray-600 ml-auto" style={{
    transform: open ? "rotate(270deg)" : "rotate(90deg)"
  }}>
              <path d="M0 0L3 3L0 6" fill="none" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round"></path>
            </svg>
          </button>
          {open ? <div role="listbox" className="absolute z-50 left-full top-0 ml-2 w-56 rounded-xl border border-zinc-950/20 dark:border-white/20 bg-white dark:bg-zinc-900 shadow-lg p-2">
              {REGIONS.map(r => {
    const selected = r.code === region;
    return <button key={r.code} type="button" role="option" aria-selected={selected ? "true" : "false"} onClick={() => onSelect(r.code)} className={"w-full flex items-center justify-between px-3 py-2 rounded-lg text-sm hover:bg-zinc-950/5 dark:hover:bg-white/10 text-zinc-950 dark:text-white" + (selected ? " font-medium" : "")}>
                    <span style={selected ? {
      color: "#ff2038"
    } : undefined}>{r.label}</span>
                    <span className={selected ? "ml-3" : "ml-3 invisible"} style={selected ? {
      color: "#ff2038"
    } : undefined}>✓</span>
                  </button>;
  })}
            </div> : null}
        </div>
      </div>
      <div ref={containerRef} className="prose dark:prose-invert max-w-none">{children}</div>
    </div>;
};

Business Processing Reporting shows how well documents are processed and provides end-to-end transaction traceability for auditing. The Warehouse captures all transactions (completed and in progress) for analysis and visualization in business intelligence tools. Data is retained for 12 months, enabling analysis and auditing over defined time periods.

The following data is tracked:

* Transaction ID.
* Skill ID and version.
* Processing path by steps:
  * Step types
  * Names
  * Date and time of the start and finish of the step
  * Duration (in seconds)
* Manual Review Operator name and email.
* Document and transaction registration parameters.

<Info>
  The Warehouse does not store information about document processing events in activities that are never executed according to their settings. For example, the Assemble by files setting corresponds to the default behavior of Vantage, therefore document processing in this activity will be skipped in a workflow.
</Info>

## Understanding v1 vs v2 behavior

Before migrating, it's important to understand that v1 and v2 differ in more than the shape of the API: they define the reporting period differently, by design. Expect different totals when comparing the two versions, not just a different request/response format.

**v1 filters by transaction, then returns every step of those transactions.** If a transaction's steps overlap the `startDate`/`endDate` filter window at all, all of its steps come back, including ones completed weeks before `startDate` or after `endDate`.

**v2 filters by step.** Only the individual steps whose own `CompletedUtc` timestamp falls within the `startDate`/`endDate` window are returned; the rest of the transaction's steps are excluded, even if other steps of that same transaction fall inside the window.

### Synchronous vs. asynchronous requests

**v1** is a single synchronous call: you send a GET request with query parameters and receive the report data directly in the response. **v2** uses an asynchronous model instead: you submit a request, poll its status, then download the results once the report is ready. This change lets v2 handle much larger data requests without timing out.

v1 is deprecated, but customers can continue using it; there's currently no scheduled removal date.

### Reporting period scope

<Warning>
  The v1 and v2 endpoints define the reporting period differently. This is expected behavior, not a bug, but it means totals from the two endpoints (or from v2 reports using different date ranges) are not directly comparable.

  * **v1** returns *all* steps belonging to any transaction that was active during the requested period, including steps that occurred outside the period's start and end dates. For example, if a transaction started before the period began or finished after it ended, v1 still returns every step of that transaction.
  * **v2** returns *only* the steps that actually occurred within the requested period. Steps falling outside the `startDate`/`endDate` window are excluded, even if they belong to a transaction that is partially within the period.

  As a result, migrating from v1 to v2 can produce lower or different totals for the same nominal date range, since v2 no longer includes steps that fall outside the window.
</Warning>

Because v2 filters on each step's own `CompletedUtc`, every step belongs to exactly one time window, no matter how you slice the range: a set of daily reports will sum to the same total as one report covering the equivalent multi-day range. This is a meaningful improvement over v1, where a step's inclusion depends on whether its transaction was active during the window rather than the step's own completion time, so v1 totals aren't guaranteed to add up the same way across different range splits.

The one thing to keep in mind with v2: a transaction whose steps span a day boundary will have those steps appear in two different daily reports, one for each day, rather than all together in either one.

### Date filtering is based on `completedUtc`

In the v2 endpoint, both `startDate` and `endDate` filter against each step's own `CompletedUtc` timestamp, not against any transaction-level start or end time.

Because each step in a transaction (for example, Input, Classification, Extraction, Manual Review, Output) has its own `CompletedUtc` value, the steps of a single transaction can be spread across different dates. Each step is evaluated and included or excluded independently, based solely on its own completion time.

If a transaction step gets reprocessed, corrected, re-run through Manual Review, or retried for any reason, its `CompletedUtc` gets updated to the new completion time. In v2, this only affects results when the query's `endDate` is in the future, that is, when the window is still open. Once a query's `endDate` is in the past, its results are stable: reprocessing stamps a step with the current time, which by definition falls after a window that has already closed, so it can't retroactively enter or leave that report.

### In-progress steps can appear in results

An export can include steps that haven't completed yet. If a transaction has a step still in progress (for example, status `Processing` or `WaitingForManualReview`) when the report is generated, that step can still appear in the results, shown with its in-progress status and no `CompletedUtc` value, as long as some other part of the transaction falls within the requested period.

This means a single export can mix finalized steps (with a `CompletedUtc` inside the window) and pending steps (with no completion timestamp at all). Check the `Status` column for each row rather than assuming every returned step represents a completed event.

### Recommended approach for a daily report

A common goal is reporting on the previous day's transactions. Use **v2** for this, with `startDate` and `endDate` set to the previous day's 00:00:00–23:59:59 UTC window. Since v2 filters on each step's own `CompletedUtc`, this returns exactly the steps that completed that day, giving you clean, consistent day-over-day totals.

Avoid using **v1** for this purpose. Because v1 returns every step of any transaction active during the window, a transaction with steps completed weeks before or after your target day still comes back in full, pulling unrelated steps into what should be a single day's numbers.

One tradeoff to keep in mind with the v2 approach: a transaction whose steps span midnight will have its steps split across two daily reports, one for each day, rather than appearing entirely in either one. This is expected; see Reporting period scope above.

As long as `endDate` is for a day that's already fully in the past, the report is stable and reproducible: re-running the same query later returns the same results. If you instead query a range that includes the current, still-in-progress day, results can change between runs as more steps complete (see Date filtering is based on `CompletedUtc` above).

## Migrating from v1 to v2

### What's New?

In the request (`/api/reporting/v2/exports/transaction-steps`):

* Filters have moved from query parameters to the request body (`filters` JSON object).
* `startDate`, specified inside the `filters` object, is now required.
* New field: `sendEmailNotification` (true/false) - send an email to the report request user when the report is ready to download.

In the final result's (`/api/reporting/v2/exports/transaction-steps/{{requestId}}/result/{fileIndex}`) downloaded CSV files, two columns have been added:

* `DocumentsCount`: The number of processed documents in a transaction.
* `PagesCount`: The number of processed pages in a transaction.

### API usage differences

v1 uses a single GET request with query parameters and returns the report directly. v2 moves filters into the request body of a POST request, then splits the process into three calls: request the report, poll its status, and download the results once it's ready.

<VantageRegion>
  ```http theme={null}
  // v1: One synchronous call with query parameters
  1. GET https://vantage-us.abbyy.com/api/reporting/v1/transaction-steps?skillId=ABCD&startDate=2025-11-01&endDate=2025-11-18

  // v2: Multiple async calls
  1. POST https://vantage-us.abbyy.com/api/reporting/v2/exports/transaction-steps
  {
    "filters": {
      "skillId": "d0e27b2d-bcc6-4129-bfd1-c1e37ee3efae",
      "transactionId": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
      "startDate": "2025-11-03T17:19:54.386Z",
      "endDate": "2025-11-17T20:05:26.097Z"
    },
    "sendEmailNotification": true
  }

  // Receive request Id
  2. GET https://vantage-us.abbyy.com/api/reporting/v2/exports/transaction-steps/{{requestId}}/status

  // Once status = "Succeeded", download the report files
  3. GET https://vantage-us.abbyy.com/api/reporting/v2/exports/transaction-steps/{{requestId}}/result/{fileIndex}
  ```
</VantageRegion>

Continue reading for details on how the v2 endpoint works below.

## Downloading a data report

<Note>
  Only users with the **Tenant Administrator** and **Processing Supervisor** role can download a data report from the Warehouse. For more information, see Role-based access control.
</Note>

You can obtain data from the Warehouse in a CSV file using the Vantage API. To do so, send a **POST** request to the following resource:

<VantageRegion>
  ```text theme={null}
  POST https://vantage-us.abbyy.com/api/reporting/v2/exports/transaction-steps
  ```
</VantageRegion>

A request body should include the following properties within a `filters` object:

* **skillId**. The ID of the skill the transactions of which should be downloaded. Optional.
* **transactionId**. The ID of the transaction to filter by. Optional.
* **startDate**. The first day of the period (sample formatting: 2022-01-07T13:03:38, time should be in UTC) for which the transactions should be downloaded. Filters against each step's `CompletedUtc` timestamp. **Required.**
* **endDate**. The last day of the period (sample formatting: 2022-09-07T13:03:38, time should be in UTC) for which the transactions should be downloaded. Filters against each step's `CompletedUtc` timestamp. Optional.
* **sendEmailNotification**. Send an email to the user who created the report request, informing them the report is ready for download. Optional.

```json theme={null}
{
  "filters": {
    "skillId": "d0e27b2d-bcc6-4129-bfd1-c1e37ee3efae",
    "transactionId": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
    "startDate": "2025-11-03T17:19:54.386Z",
    "endDate": "2025-11-17T20:05:26.097Z"
  },
  "sendEmailNotification": true
}
```

Report requests are executed asynchronously, so the response returns a `requestId` used to check the request status.

Result:

```json theme={null}
{
  "requestId": "8f772512-099c-4050-8dd3-6c4d7af69747"
}
```

To check the status of the report, pass the `requestId` in the GET request:

<VantageRegion>
  ```http theme={null}
  GET https://vantage-us.abbyy.com/api/reporting/v2/exports/transaction-steps/{{requestId}}/status
  ```
</VantageRegion>

When the report has been created, the `status` is "Succeeded" and `totalFileCount` shows the number of files available to download:

```json theme={null}
{
  "status": "Succeeded",
  "totalFileCount": 3,
  "filters": {
      "skillId": "d0e27b2d-bcc6-4129-bfd1-c1e37ee3efae",
      "startDate": "2025-11-03T17:19:54.386+00:00",
      "endDate": "2025-11-17T20:05:26.097+00:00"
  }
}
```

To download the resulting report files, make a GET request to the following, once again passing the `requestId` and adding the `fileIndex`, the zero-based index of the file. For example, if `"totalFileCount": 3`, then available file indexes would be 0, 1, and 2.

<VantageRegion>
  ```http theme={null}
  GET https://vantage-us.abbyy.com/api/reporting/v2/exports/transaction-steps/{{requestId}}/result/{fileIndex}
  ```
</VantageRegion>

Here's a sample of what the CSV response looks like:

| **SkillId**                          | **SkillVersion** | **SkillName**  | **TransactionId**                    | **StepName** | **StepType**   | **ManualReviewOperatorName** | **ManualReviewOperatorEmail** | **StartedUtc**      | **CompletedUtc**    | **Status**           | **Duration** | **DocumentsCount** | **PagesCount** | **document\_SourceFileName** | **document\_SourceType** | **transaction\_App** |
| ------------------------------------ | ---------------- | -------------- | ------------------------------------ | ------------ | -------------- | ---------------------------- | ----------------------------- | ------------------- | ------------------- | -------------------- | ------------ | ------------------ | -------------- | ---------------------------- | ------------------------ | -------------------- |
| d0e27b2d-bcc6-4129-bfd1-c1e37ee3efae | 1                | Redaction Test | 6d7e9eeb-86e3-4952-8e29-3f76b3fae59f | Input        | Input          |                              |                               | 11/17/2025 19:37:52 | 11/17/2025 19:38:01 | FinishedSuccessfully | 9            |                    |                | Invoice CA\_2.pdf            | PublicAPI                | PublicAPI            |
| d0e27b2d-bcc6-4129-bfd1-c1e37ee3efae | 1                | Redaction Test | 6d7e9eeb-86e3-4952-8e29-3f76b3fae59f | OCR          | Ocr            |                              |                               | 11/17/2025 19:38:02 | 11/17/2025 19:38:17 | FinishedSuccessfully | 15           |                    |                | Invoice CA\_2.pdf            | PublicAPI                | PublicAPI            |
| d0e27b2d-bcc6-4129-bfd1-c1e37ee3efae | 1                | Redaction Test | 6d7e9eeb-86e3-4952-8e29-3f76b3fae59f | Classify     | Classification |                              |                               | 11/17/2025 19:38:17 | 11/17/2025 19:38:20 | FinishedSuccessfully | 3            |                    |                | Invoice CA\_2.pdf            | PublicAPI                | PublicAPI            |
| d0e27b2d-bcc6-4129-bfd1-c1e37ee3efae | 1                | Redaction Test | 6d7e9eeb-86e3-4952-8e29-3f76b3fae59f | Extract      | Extraction     |                              |                               | 11/17/2025 19:38:21 | 11/17/2025 19:38:44 | FinishedSuccessfully | 23           |                    |                | Invoice CA\_2.pdf            | PublicAPI                | PublicAPI            |
| d0e27b2d-bcc6-4129-bfd1-c1e37ee3efae | 1                | Redaction Test | 6d7e9eeb-86e3-4952-8e29-3f76b3fae59f | Output       | Output         |                              |                               | 11/17/2025 19:38:47 | 11/17/2025 19:39:01 | Failed               | 13           |                    |                | Invoice CA\_2.pdf            | PublicAPI                | PublicAPI            |

### Response Structure

Each row in a CSV file is an operation performed on a transaction. For example, the import of documents, recognition, or manual review. For each operation in the Warehouse, its details are stored in columns:

| Column                        | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| :---------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `SkillId`                     | The skill ID.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `SkillVersion`                | The version of the skill.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| `SkillName`                   | The name of the skill.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `TransactionId`               | ID of the transaction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `StepName`                    | The name of the event or the name of the activity in case of the Process skill.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `StepType`                    | The type of event. Possible values: <br />- Input (available for all skill types) <br />- Ocr (available for OCR skills or Process skills with added OCR activity) <br />- Classification (available for Classification skills or Process skills with added Classification activity) <br />- Extraction (available for all skill types) <br />- Condition (available for Process skills with added Condition activity) <br />- CustomActivity (available for Process skills with added Custom activity) <br />- WaitingForManualReview (available for Process skills with added **Manual Review** activity). The amount of time during which a transaction is waiting for manual review <br />- ManualReview (available for Process skills with added **Manual Review** activity). The amount of time during which the Operator is verifying a transaction <br />- Output (available for all skill types) |
| `ManualReviewOperatorName`    | The name of the Manual Review Operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `ManualReviewOperatorEmail`   | The email of the Manual Review Operator.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `StartedUtc`                  | Start time of the event (UTC). For example, 5/3/2022 1:59:02 PM.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `CompletedUtc`                | End time of the event (UTC).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| `Status`                      | The status of the event, as a single token in the CSV. Possible values: <br />- Processing <br />- FinishedSuccessfully <br />- Canceled <br />- Failed                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `Duration`                    | Duration of the event (in seconds).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `DocumentsCount`              | The number of processed documents in a transaction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `PagesCount`                  | The number of processed pages in a transaction.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `document_*`, `transaction_*` | The document or transaction parameters passed for processing. The prefix **document\_** is added to document parameters in the header, and the **transaction\_** prefix is added to the transaction parameters. For example, **document\_SourceFileName**. If a transaction contains documents with parameters identical in name but different in value, the Warehouse will list all unique values of this parameter separated by commas. For example, all filenames within a transaction.                                                                                                                                                                                                                                                                                                                                                                                                                |

The prepared data is stored for 2 weeks after the request is completed. Data obtained in CSV format may be further analyzed in any BI tool.

## Retrieving a List of Reporting Requests

To retrieve the list of reporting requests made within a designated time period, make a GET request to the following endpoint, where `createdFrom` and `createdTo` are the date range and `statusFilter` is one of the following values: `New`,`Queued`,`Processing`,`Succeeded`,`Failed`, or `Cancelled`. This is useful in the case of misplaced request ids.

<VantageRegion>
  ```http theme={null}
  GET https://vantage-us.abbyy.com/api/reporting/v2/exports/transaction-steps?statusFilter=Succeeded&createdFrom=2025-11-05&createdTo=2025-11-17
  ```
</VantageRegion>

The response includes an array of reporting requests.

```json theme={null}
{
  "requests": [
    {
      "requestId": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
      "status": "New",
      "completedUtc": "2025-11-18T22:22:00.294Z",
      "createdUtc": "2025-11-18T22:20:49.294Z",
      "totalFileCount": 2,
      "filters": {
        "skillId": "d0e27b2d-bcc6-4129-bfd1-c1e37ee3efae",
        "startDate": "2025-11-03T17:19:54.386+00:00",
        "endDate": "2025-11-17T20:05:26.097+00:00"
      }
    },
    {
      "requestId": "48293032-5717-4562-b3fc-2c963f66afa6",
      "status": "Succeeded",
      "completedUtc": "2025-12-18T22:22:00.294Z",
      "createdUtc": "2025-12-18T22:20:49.294Z",
      "totalFileCount": 4,
      "filters": {
        "skillId": "dk3ioda-bcc6-4129-bfd1-c1e37ee3efae",
        "startDate": "2025-11-03T17:19:54.386+00:00",
        "endDate": "2025-11-17T20:05:26.097+00:00"
      }
    }
  ]
}
```