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

# Generate Transaction PDF Report

> Download a monitored transaction as a PDF report with its verdict, parties, alerts, rule runs, screening results and related transactions.



Generate Transaction PDF Report API Prompt
        Copy prompt to clipboard



      
      

\<pre>

\`Download one Didit monitored transaction as a PDF report through the Management API.

Endpoint:
GET https://verification.didit.me/v3/organization/{organization_id}/application/{application_id}/transactions/{transaction_uuid}/pdf/

Authentication:
Use the x-api-key header with my Didit API key. A scoped key needs media: read and transactions: read, because a PDF report counts as media. Keys limited to specific workflows or to approved sessions cannot call this endpoint.

Goal:
\- Get a PDF of a transaction for an audit file, a handoff to another team, or a regulator request.

Path parameters:
\- organization_id: my organization UUID.
\- application_id: the UUID of the application my API key belongs to. Any other application returns 403.
\- transaction_uuid: the Didit transaction uuid, not my own txn_id.

Behavior:
\- The response body is the PDF itself (Content-Type: application/pdf). Do not parse it as JSON.
\- Content-Disposition is always attachment; filename=transaction_{transaction_uuid}.pdf.
\- The report covers the overview and verdict, parties and payment methods, custom properties, alerts and rule runs, screening and Travel Rule results, the network summary, the cost breakdown, up to 50 related transactions and the 20 most recent activity entries.
\- It is rendered from the transaction's current data on every call. Nothing is stored and nothing is billed. Rendering can take a few seconds, so use a generous client timeout.

Example call:
curl -X GET "https://verification.didit.me/v3/organization/{organization_id}/application/{application_id}/transactions/{transaction_uuid}/pdf/" \
-H "x-api-key: YOUR_API_KEY" \
-o transaction_report.pdf

Failure modes (JSON bodies):
\- 401: the API key has expired.
\- 403: missing or invalid API key ({"detail": "Authentication credentials were not provided or are invalid."}), an application_id that is not my key's application ({"detail": "You do not have permission to perform this action."}), a scoped key without media: read ({"detail": "This API key has no read access to media."}) or transactions: read, a key with workflow or status limits, or a request from outside the key's IP allowlist.
\- 404: no transaction with this uuid in my application ({"detail": "No Transaction matches the given query."}).
\- 429: more than 600 GET requests per minute with this key; wait Retry-After seconds and retry.

Side effects: none.

For the full integration shape, see /integration/integration-prompt.`

\</pre>



      
      

Paste into

The report is generated on demand from the transaction's current data, so call it again after a status change to get an up-to-date copy. Unlike the other transaction endpoints, it lives on an application-scoped path: put your organization ID and the ID of the application your API key belongs to in the URL. See [Find your organization ID](/getting-started/api-authentication.md#find-your-organization-id).> [!NOTE]
>
> A PDF report counts as media. A [scoped API key](/console/api-keys.md) needs **media: read** as well as **transactions: read**, and a key without media access gets `403` even when it can read the transaction as JSON with [Get transaction](/management-api/transactions/get.md).


## OpenAPI

````yaml GET /v3/organization/{organization_id}/application/{application_id}/transactions/{transaction_uuid}/pdf/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: Identity verification API. Authenticate with x-api-key header.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/organization/{organization_id}/application/{application_id}/transactions/{transaction_uuid}/pdf/:
    get:
      tags:
        - Transactions
      summary: Download a transaction PDF report
      description: >-
        Render one monitored transaction as a PDF report: overview and verdict,
        parties and payment methods, custom properties, alerts and rule runs,
        screening and Travel Rule results, the network summary, the cost
        breakdown, up to 50 related transactions and the 20 most recent activity
        entries. The body is the PDF itself (`application/pdf`), not JSON.


        The report is rendered from the transaction's current data on every
        call, so request it again after a status change. Nothing is stored and
        nothing is billed. Rendering can take a few seconds, so use a generous
        client timeout.


        This endpoint lives on an application-scoped path: put your organization
        ID and the ID of the application your API key belongs to in the URL
        ([find your organization
        ID](https://docs.didit.me/getting-started/api-authentication#find-your-organization-id)).
        A PDF report counts as media: a scoped API key needs `media: read` and
        `transactions: read`, and a key limited to some workflows or to approved
        sessions cannot call it.
      operationId: get_transaction_pdf
      parameters:
        - name: organization_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: Organization UUID.
          example: 11111111-2222-3333-4444-555555555555
        - name: application_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: >-
            Application UUID. Must be the application the API key belongs to: a
            key used on any other application gets `403`.
          example: aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee
        - name: transaction_uuid
          in: path
          required: true
          description: >-
            Didit transaction UUID: the `uuid` returned by `POST
            /v3/transactions/` and `GET /v3/transactions/`. Your own `txn_id` is
            not accepted.
          schema:
            type: string
            format: uuid
          example: abcdef12-3456-7890-abcd-ef1234567890
      responses:
        '200':
          description: The rendered PDF, returned directly as binary `application/pdf`.
          headers:
            Content-Disposition:
              description: >-
                Always `attachment;
                filename=transaction_{transaction_uuid}.pdf`.
              schema:
                type: string
                example: >-
                  attachment;
                  filename=transaction_abcdef12-3456-7890-abcd-ef1234567890.pdf
          content:
            application/pdf:
              schema:
                type: string
                format: binary
        '401':
          description: >-
            The API key has expired. Only a key created with an expiry date can
            expire; after that date every request with it answers `401`.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              examples:
                Expired key:
                  value:
                    detail: This API key has expired.
        '403':
          description: >-
            The request is not allowed. Read `detail`: a missing or invalid API
            key (never `401`), an `application_id` that is not the key's
            application, a scoped key without `media: read` or `transactions:
            read`, a key limited to workflows or approved sessions, or a request
            from outside the key's IP list.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              examples:
                Missing or invalid key:
                  value:
                    detail: >-
                      Authentication credentials were not provided or are
                      invalid.
                Another application:
                  value:
                    detail: You do not have permission to perform this action.
                Scoped key without media read:
                  value:
                    detail: This API key has no read access to media.
                Scoped key without transactions read:
                  value:
                    detail: This API key has no read access to transactions.
                Key limited to workflows or approved sessions:
                  value:
                    detail: >-
                      This API key only reaches sessions inside its workflow or
                      status limits, so it can't use this endpoint.
                Outside the key's IP list:
                  value:
                    detail: This API key can't be used from this IP address.
        '404':
          description: >-
            No transaction with this UUID exists in the application (never
            created, deleted, or owned by another application). A
            `transaction_uuid` that is not a UUID does not reach the API: it
            returns a `404` HTML page instead of this JSON body.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              examples:
                Not found:
                  value:
                    detail: No Transaction matches the given query.
        '429':
          description: >-
            More than 600 GET requests per minute with this API key. Wait the
            number of seconds in `Retry-After`, then retry.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
              examples:
                Throttled:
                  value:
                    detail: >-
                      GET request rate limit exceeded. You can make up to 600
                      requests per minute.
          headers:
            Retry-After:
              description: Seconds until the current one-minute window resets.
              schema:
                type: integer
                example: 23
            X-RateLimit-Limit:
              description: Requests allowed per minute in this budget.
              schema:
                type: integer
            X-RateLimit-Remaining:
              description: Requests left in the current window.
              schema:
                type: integer
            X-RateLimit-Reset:
              description: Unix time when the window resets.
              schema:
                type: integer
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl --fail -X GET
            'https://verification.didit.me/v3/organization/11111111-2222-3333-4444-555555555555/application/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/transactions/abcdef12-3456-7890-abcd-ef1234567890/pdf/'
            \
              -H 'x-api-key: YOUR_API_KEY' \
              --output transaction_report.pdf
        - lang: python
          label: Python
          source: |-
            import os

            import requests

            org_id = '11111111-2222-3333-4444-555555555555'
            app_id = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
            transaction_uuid = 'abcdef12-3456-7890-abcd-ef1234567890'
            resp = requests.get(
                f'https://verification.didit.me/v3/organization/{org_id}/application/{app_id}'
                f'/transactions/{transaction_uuid}/pdf/',
                headers={'x-api-key': os.environ['DIDIT_API_KEY']},
                timeout=60,
            )
            resp.raise_for_status()
            with open(f'transaction_{transaction_uuid}.pdf', 'wb') as fh:
                fh.write(resp.content)
        - lang: javascript
          label: JavaScript
          source: >-
            import { writeFile } from 'node:fs/promises';


            const orgId = '11111111-2222-3333-4444-555555555555';

            const appId = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee';

            const transactionUuid = 'abcdef12-3456-7890-abcd-ef1234567890';

            const resp = await fetch(
              `https://verification.didit.me/v3/organization/${orgId}/application/${appId}/transactions/${transactionUuid}/pdf/`,
              { headers: { 'x-api-key': process.env.DIDIT_API_KEY } },
            );

            if (!resp.ok) throw new Error(`PDF generation failed:
            ${resp.status}`);

            await writeFile(`transaction_${transactionUuid}.pdf`,
            Buffer.from(await resp.arrayBuffer()));
components:
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        Your application's API key, from Developers -> API keys in the Business
        Console. The primary key has full access. A named key can be scoped:
        none, read or write per resource, limited to some workflows or to
        approved sessions, to a list of IP addresses, and to an expiry date. 401
        means the key is missing, wrong, revoked or expired; 403 means the key
        has no access to this resource or action, or the request came from an
        address outside its IP list; 404 on a session route means the session is
        outside the key's workflows or statuses. A key without media access
        receives image, video and PDF URLs as null, and a key without sessions
        write receives session links and tokens as null. See
        https://docs.didit.me/console/api-keys.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.