EU Battery Passport Validator & DPP Generator (zentrafoundry/eu-battery-passport-readiness-auditor) Actor

Traceable battery DPP readiness assessments, evidence gaps, conflict findings and preparation packages — not legal certification or Registry submission.

• URL: https://apify.com/zentrafoundry/eu-battery-passport-readiness-auditor.md
• Developed by: Zentra (community)
• Categories: Other, Developer tools, Automation
• Stats: 2 total users, 1 monthly users, 94.7% runs succeeded, 0 bookmarks
• User rating: No ratings yet

Pricing

from $1,500.00 / 1,000 product model auditeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A".

How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows.

• AI agents and MCP clients — the Apify MCP server at https://mcp.apify.com (remote, streamable HTTP, OAuth on first use).
• Agentic workflows and local Actor development — Agent Skills with the Apify CLI: npm install -g apify-cli, then apify login.
• JavaScript/TypeScript projects — the official JS/TS client: npm install apify-client.
• Python projects — the official Python client: pip install apify-client.
• Any other language — the REST API.

For usage examples, see the API section below.

For more details, see Apify documentation as Markdown index and Markdown full-text.

README

EU Battery Passport Validator & DPP Generator

Turn incomplete battery product data and evidence into traceable EU Digital Product Passport (DPP) readiness assessments and preparation packages.

This Actor is a readiness aid, not a legal certification, conformity assessment, official DPP, or EU DPP Registry submission service. It never logs in to, registers with, or submits data to the EU DPP Registry.

Start here — readiness example (not certification)

Default Store path (matches the public input example):

{
  "mode": "audit-and-build",
    "sector": "battery",
      "useExampleData": false,
        "strictness": "official-evidence-only",
          "maxProducts": 1,
            "records": [{
                "productId": "BAT-100",
                    "productName": "Example industrial battery",
                        "manufacturer": "Example Manufacturer",
                            "batteryCategory": "industrial",
                                "model": "BAT-100",
                                    "capacityKwh": 4.2,
                                        "batteryChemistry": "LFP",
                                            "carbonFootprintKgCo2e": 220,
                                                "manufacturingLocation": "DE",
                                                    "evidence": [{
                                                          "field": "capacityKwh",
                                                                "value": 4.2,
                                                                      "sourceType": "manufacturer_technical_document",
                                                                            "sourceUrl": "https://example.com/battery-technical-sheet.pdf",
                                                                                  "documentHash": "sha256:replace-with-real-hash"
                                                                                      }]
                                                                                        }],
                                                                                          "outputFormats": ["json", "csv", "html", "qr"]
                                                                                          }
                                                                                          ```

                                                                                          Replace example.com URLs with public documents you are entitled to retrieve. A completed buyer-supplied model assessment may charge $1.50 (`product_model_audited`). This Actor is readiness only — not legal certification, not Registry submission.

                                                                                          Optional free QA fixture: set `"useExampleData": true` for three synthetic records (no buyer-value charge).

                                                                                          ### Input contract

                                                                                          The public form and runtime use one canonical input contract. `sourceDatasetId` is the dataset field and `maxProducts` is the workload field. Earlier `existingDatasetId` and `maxItems` names are accepted only as non-public compatibility aliases; new integrations must use the canonical names.

                                                                                          | Field | Use |
                                                                                          | --- | --- |
                                                                                          | `mode` | `audit`, `audit-and-build`, `validate-existing`, or `monitor`. |
                                                                                          | `sector` | `battery` only. No unfinished sectors are exposed. |
                                                                                          | `useExampleData` | Run the deterministic free fixture instead of buyer data. |
                                                                                          | `strictness` | `official-evidence-only` or `allow-unverified`. |
                                                                                          | `language` | `en` only in this release. |
                                                                                          | `records`, `productUrls`, `evidenceUrls`, `sourceDatasetId` | Audit-mode product and evidence inputs. |
                                                                                          | `dppRecords` | Existing structured DPP/product records, primarily for `validate-existing`. |
                                                                                          | `dppUrls`, `monitorChecks` | Public deployed DPP URLs and monitor controls, primarily for `monitor`. |
                                                                                          | `outputFormats`, `includeQrCodes`, `includeHtmlReport` | Package controls. JSON readiness data and DPP preparation JSON/XML remain machine-readable core artifacts. |
                                                                                          | `maxProducts`, `requestTimeoutSecs`, `maxDocumentSizeMb` | Bounded work controls: 1–500 products, 5–120 seconds per request, and 1–25 MB per document. |

                                                                                          Public URL inputs accept credential-free HTTP(S) JSON, XML, CSV, text/HTML, and text-based PDFs. Every hostname and redirect is checked against private, local, and reserved address space. The Actor never bypasses a login, paywall, CAPTCHA, or access control.

                                                                                          ### Examples

                                                                                          #### Product and evidence URLs

                                                                                          ```json
                                                                                          {
                                                                                            "mode": "audit-and-build",
                                                                                              "useExampleData": false,
                                                                                                "productUrls": ["https://example.com/battery-product"],
                                                                                                  "evidenceUrls": ["https://example.com/battery-technical-sheet.pdf"]
                                                                                                  }
                                                                                                  ```

                                                                                                  The example domains are placeholders: replace them with public documents you are entitled to retrieve. Each successfully completed buyer-supplied product-model assessment may trigger the documented pay-per-event charges.

                                                                                                  #### Battery product records

                                                                                                  ```json
                                                                                                  {
                                                                                                    "mode": "audit-and-build",
                                                                                                      "useExampleData": false,
                                                                                                        "strictness": "official-evidence-only",
                                                                                                          "records": [{
                                                                                                              "productId": "BAT-100",
                                                                                                                  "productName": "Example industrial battery",
                                                                                                                      "manufacturer": "Example Manufacturer",
                                                                                                                          "batteryCategory": "industrial",
                                                                                                                              "model": "BAT-100",
                                                                                                                                  "capacityKwh": 4.2,
                                                                                                                                      "batteryChemistry": "LFP",
                                                                                                                                          "carbonFootprintKgCo2e": 220,
                                                                                                                                              "manufacturingLocation": "DE",
                                                                                                                                                  "evidence": [{
                                                                                                                                                        "field": "capacityKwh",
                                                                                                                                                              "value": 4.2,
                                                                                                                                                                    "sourceType": "manufacturer_technical_document",
                                                                                                                                                                          "sourceUrl": "https://example.com/battery-technical-sheet.pdf",
                                                                                                                                                                                "documentHash": "sha256:replace-with-real-hash"
                                                                                                                                                                                    }]
                                                                                                                                                                                      }]
                                                                                                                                                                                      }
                                                                                                                                                                                      ```

                                                                                                                                                                                      Strict mode accepts `official_regulatory`, `manufacturer_technical_document`, `manufacturer_declaration`, `verified_test_report`, and `conformity_document`, each with a stable URL or document hash. It never manufactures provenance, chooses between conflicts, or infers omitted values.

                                                                                                                                                                                      #### Existing Apify dataset

                                                                                                                                                                                      ```json
                                                                                                                                                                                      {
                                                                                                                                                                                        "mode": "audit",
                                                                                                                                                                                          "useExampleData": false,
                                                                                                                                                                                            "sourceDatasetId": "DATASET_ID"
                                                                                                                                                                                            }
                                                                                                                                                                                            ```

                                                                                                                                                                                            The dataset must be readable to the run. Rows are evaluated as battery product records.

                                                                                                                                                                                            #### Existing DPP validation

                                                                                                                                                                                            ```json
                                                                                                                                                                                            {
                                                                                                                                                                                              "mode": "validate-existing",
                                                                                                                                                                                                "useExampleData": false,
                                                                                                                                                                                                  "dppRecords": [{}]
                                                                                                                                                                                                  }
                                                                                                                                                                                                  ```

                                                                                                                                                                                                  An empty object intentionally returns structured missing-data findings; it is useful for checking that your DPP mapping supplies all required fields.

                                                                                                                                                                                                  #### Monitoring

                                                                                                                                                                                                  ```json
                                                                                                                                                                                                  {
                                                                                                                                                                                                    "mode": "monitor",
                                                                                                                                                                                                      "dppUrls": ["https://example.com/battery/BAT-001"],
                                                                                                                                                                                                        "monitorChecks": ["availability", "https", "structured-document"]
                                                                                                                                                                                                        }
                                                                                                                                                                                                        ```

                                                                                                                                                                                                        Monitor mode checks bounded availability, credential-free HTTPS URL syntax, and a recognizable structured-document content type. It does not claim Registry validation, identifier-authority checks, QR-target verification, or evidence-link crawling.

                                                                                                                                                                                                        ### Outputs

                                                                                                                                                                                                        Each readiness result contains a transparent score and status, scope note, missing data/evidence, conflicts, validation findings, deterministic preparation identifier, QR target, and draft DPP preparation object. The default key-value store uses the `DPP-` prefix and can include:

                                                                                                                                                                                                        - `DPP-SUMMARY.json`
                                                                                                                                                                                                        - `DPP-EVIDENCE.csv` and `DPP-MISSING-DATA.csv` when CSV is selected
                                                                                                                                                                                                        - `DPP-VALIDATION-ERRORS.json`
                                                                                                                                                                                                        - `DPP-PREPARATION.json` and `DPP-PREPARATION.xml`
                                                                                                                                                                                                        - `DPP-REPORT.html` when HTML is selected
                                                                                                                                                                                                        - `DPP-QR-MAPPING.json` and one PNG per product when QR is selected
                                                                                                                                                                                                        - `DPP-ARTIFACT-INDEX.json`, plus `DPP-PREPARATION-PACKAGE.zip` when ZIP is selected

                                                                                                                                                                                                        A QR code targets a supplied valid HTTPS DPP URL only when one is present. Otherwise it encodes a visibly non-deployable Zentra preparation URI.

                                                                                                                                                                                                        ### Pricing

                                                                                                                                                                                                        The built-in fixture is free. A successful buyer-supplied product-model assessment charges **$1.50** once via `product_model_audited`. In `audit-and-build` and `validate-existing`, a real machine-readable preparation record can charge **$0.01** via `dpp_record_generated`. Retries, invalid input, skipped duplicates, and the synthetic fixture do not double-charge or emit buyer-value events.

                                                                                                                                                                                                        ### Regulatory sources and limits

                                                                                                                                                                                                        The transparent `2026-08-14-verified` ruleset is intentionally `partial`. It cites the current consolidated [Battery Regulation](https://eur-lex.europa.eu/legal-content/EN/TXT/?qid=1772072525197\&uri=CELEX%3A02023R1542-20250731), the European Commission’s [Digital Product Passport overview](https://single-market-economy.ec.europa.eu/single-market/digital-product-passport_en), [DPP Registry guidance](https://single-market-economy.ec.europa.eu/single-market/digital-product-passport/dpp-registry_en), and [ESPR](https://eur-lex.europa.eu/eli/reg/2024/1781/oj). Consult qualified legal and technical advisers for applicability, final access-rights rules, official data semantics, technical hosting, identifiers, and any Registry interaction.

                                                                                                                                                                                                        # Actor input Schema

                                                                                                                                                                                                        ## `mode` (type: `string`):

                                                                                                                                                                                                        Choose audit for readiness findings, audit-and-build for readiness findings plus a preparation package, validate-existing for supplied DPP records, or monitor for deployed DPP URLs.

                                                                                                                                                                                                        ## `sector` (type: `string`):

                                                                                                                                                                                                        This specialized Actor implements battery readiness only.

                                                                                                                                                                                                        ## `useExampleData` (type: `boolean`):

                                                                                                                                                                                                        Use the synthetic fixture instead of the default live buyer-shaped readiness example. It needs no credentials, does not contact a Registry, and never emits buyer-value events.

                                                                                                                                                                                                        ## `strictness` (type: `string`):

                                                                                                                                                                                                        Official-evidence-only accepts listed technical, declaration, test, conformity, or regulatory evidence with a stable URL or document hash. Allow unverified keeps supplied claims visible but not upgraded to proof.

                                                                                                                                                                                                        ## `language` (type: `string`):

                                                                                                                                                                                                        English output is implemented in this release.

                                                                                                                                                                                                        ## `records` (type: `array`):

                                                                                                                                                                                                        Use in audit modes. Supply productId, productName, manufacturer, batteryCategory, model, capacityKwh, batteryChemistry, carbonFootprintKgCo2e, manufacturingLocation, and evidence where available. Set Use built-in example batteries to false when supplying records.

                                                                                                                                                                                                        ## `productUrls` (type: `array`):

                                                                                                                                                                                                        Use in audit modes. Credential-free public HTTP(S) product pages or JSON, XML, CSV, HTML/text documents only. Private, local, login-protected, paywalled, or CAPTCHA-protected targets are rejected.

                                                                                                                                                                                                        ## `evidenceUrls` (type: `array`):

                                                                                                                                                                                                        Use in audit modes. Credential-free public HTTP(S) JSON, XML, CSV, HTML/text, or text-based PDF documents. Documents are limited by Maximum document size.

                                                                                                                                                                                                        ## `sourceDatasetId` (type: `string`):

                                                                                                                                                                                                        Use in audit modes to consume readable rows from another Apify Actor dataset. The rows are evaluated as battery product records; the Actor does not require another account credential.

                                                                                                                                                                                                        ## `dppRecords` (type: `array`):

                                                                                                                                                                                                        Use primarily with Validate existing DPP records. Supply structured existing DPP/product records for gap, provenance, conflict, identifier, and HTTPS URL checks.

                                                                                                                                                                                                        ## `dppUrls` (type: `array`):

                                                                                                                                                                                                        Use primarily with Monitor. Supply credential-free public HTTPS DPP URLs. The Actor checks bounded availability, HTTPS syntax, and whether the response is a recognizable structured document; it never performs Registry login or submission.

                                                                                                                                                                                                        ## `outputFormats` (type: `array`):

                                                                                                                                                                                                        JSON readiness assessments and machine-readable DPP preparation JSON/XML are always retained for audit-and-build and validate-existing. Select auxiliary CSV, HTML, QR, XML, or ZIP artifacts as needed.

                                                                                                                                                                                                        ## `includeQrCodes` (type: `boolean`):

                                                                                                                                                                                                        Generate PNG QR preparation artifacts when qr is selected. Without a supplied valid HTTPS DPP URL, a QR encodes a clearly non-deployable preparation URI.

                                                                                                                                                                                                        ## `includeHtmlReport` (type: `boolean`):

                                                                                                                                                                                                        Write a buyer-readable HTML readiness summary when html is selected.

                                                                                                                                                                                                        ## `maxProducts` (type: `integer`):

                                                                                                                                                                                                        Maximum product or DPP records processed in one run. The built-in three-record fixture is never truncated. Buyer-supplied completed assessments may be billable once per unique product model.

                                                                                                                                                                                                        ## `requestTimeoutSecs` (type: `integer`):

                                                                                                                                                                                                        Maximum time for each public document or DPP URL request, including bounded redirects.

                                                                                                                                                                                                        ## `maxDocumentSizeMb` (type: `integer`):

                                                                                                                                                                                                        Maximum downloaded size for each public document. Supported range is 1–25 MB; large, private, or inaccessible documents are recorded as input diagnostics instead of causing a silent claim.

                                                                                                                                                                                                        ## `monitorChecks` (type: `array`):

                                                                                                                                                                                                        Used in Monitor mode: availability, credential-free HTTPS URL syntax, and recognizable structured-document content type. Registry validation, identifier-authority checks, QR-target verification, and evidence-link crawling are not implemented claims.

                                                                                                                                                                                                        ## Actor input object example

                                                                                                                                                                                                        ```json
                                                                                                                                                                                                        {
                                                                                                                                                                                                          "mode": "audit-and-build",
                                                                                                                                                                                                            "sector": "battery",
                                                                                                                                                                                                              "useExampleData": false,
                                                                                                                                                                                                                "strictness": "official-evidence-only",
                                                                                                                                                                                                                  "language": "en",
                                                                                                                                                                                                                    "records": [
                                                                                                                                                                                                                        {
                                                                                                                                                                                                                              "productId": "BAT-100",
                                                                                                                                                                                                                                    "productName": "Example industrial battery",
                                                                                                                                                                                                                                          "manufacturer": "Example Manufacturer",
                                                                                                                                                                                                                                                "batteryCategory": "industrial",
                                                                                                                                                                                                                                                      "model": "BAT-100",
                                                                                                                                                                                                                                                            "capacityKwh": 4.2,
                                                                                                                                                                                                                                                                  "batteryChemistry": "LFP",
                                                                                                                                                                                                                                                                        "carbonFootprintKgCo2e": 220,
                                                                                                                                                                                                                                                                              "manufacturingLocation": "DE",
                                                                                                                                                                                                                                                                                    "evidence": [
                                                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                                                      "field": "capacityKwh",
                                                                                                                                                                                                                                                                                                                "value": 4.2,
                                                                                                                                                                                                                                                                                                                          "sourceType": "manufacturer_technical_document",
                                                                                                                                                                                                                                                                                                                                    "sourceUrl": "https://example.com/battery-technical-sheet.pdf",
                                                                                                                                                                                                                                                                                                                                              "documentHash": "sha256:replace-with-real-hash"
                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                            ]
                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                  ],
                                                                                                                                                                                                                                                                                                                                                                    "productUrls": [
                                                                                                                                                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                                                                                                                                                              "url": "https://example.com/battery-product"
                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                    ],
                                                                                                                                                                                                                                                                                                                                                                                      "evidenceUrls": [
                                                                                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                                                                                                "url": "https://example.com/battery-technical-sheet.pdf"
                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                      ],
                                                                                                                                                                                                                                                                                                                                                                                                        "dppRecords": [],
                                                                                                                                                                                                                                                                                                                                                                                                          "dppUrls": [
                                                                                                                                                                                                                                                                                                                                                                                                              {
                                                                                                                                                                                                                                                                                                                                                                                                                    "url": "https://example.com/battery/BAT-001"
                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                          ],
                                                                                                                                                                                                                                                                                                                                                                                                                            "outputFormats": [
                                                                                                                                                                                                                                                                                                                                                                                                                                "json",
                                                                                                                                                                                                                                                                                                                                                                                                                                    "csv",
                                                                                                                                                                                                                                                                                                                                                                                                                                        "html",
                                                                                                                                                                                                                                                                                                                                                                                                                                            "qr"
                                                                                                                                                                                                                                                                                                                                                                                                                                              ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                "includeQrCodes": true,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  "includeHtmlReport": true,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    "maxProducts": 1,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      "requestTimeoutSecs": 15,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        "maxDocumentSizeMb": 8,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          "monitorChecks": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                              "availability",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  "https",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      "structured-document"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ```

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        # Actor output Schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## `assessments` (type: `string`):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## `preparationArtifacts` (type: `string`):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        # API

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ## JavaScript example

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ```javascript
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        import { ApifyClient } from 'apify-client';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Initialize the ApifyClient with your Apify API token
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        // Replace the '<YOUR_API_TOKEN>' with your token
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const client = new ApifyClient({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            token: '<YOUR_API_TOKEN>',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Prepare Actor input
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const input = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "useExampleData": false,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "records": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "productId": "BAT-100",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "productName": "Example industrial battery",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "manufacturer": "Example Manufacturer",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "batteryCategory": "industrial",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "model": "BAT-100",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "capacityKwh": 4.2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "batteryChemistry": "LFP",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "carbonFootprintKgCo2e": 220,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "manufacturingLocation": "DE",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "evidence": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "field": "capacityKwh",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "value": 4.2,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "sourceType": "manufacturer_technical_document",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "sourceUrl": "https://example.com/battery-technical-sheet.pdf",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "documentHash": "sha256:replace-with-real-hash"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "productUrls": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "url": "https://example.com/battery-product"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "evidenceUrls": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "url": "https://example.com/battery-technical-sheet.pdf"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            "sourceDatasetId": "",
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                "dppRecords": [],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    "dppUrls": [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        "url": "https://example.com/battery/BAT-001"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    // Run the Actor and wait for it to finish
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const run = await client.actor("zentrafoundry/eu-battery-passport-readiness-auditor").call(input);