> ## 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.

# API per creare un modello di report goAML

> Crea con Didit un modello riutilizzabile di intestazione goAML per giurisdizione, validato sui campi obbligatori prima dell'uso.



Prompt API per creare un modello di report
        Copia il prompt negli appunti



      
      

\<pre>

\`Create a FIU report template through the Management API.

Endpoint:
POST https://verification.didit.me/v3/organization/{organization_id}/application/{application_id}/report-templates/

Authentication:
Use the x-api-key header with my Didit API key.

Request body:
\{
"name": "US SAR default",         // required
"jurisdiction": "US",               // required, ISO 3166-1 alpha-2, upper-cased on save
"report_type": "SAR",               // required: SAR|STR|CTR|TTR|UTR|IFT|CBR|TFR
"field_config": {
"rentity_id": "FIU-US-00123",     // obligatory - reporting entity ID from your FIU
"submission_code": "E",           // obligatory - E (electronic) or M (manual)
"currency_code_local": "USD",     // obligatory
"enabled_fields": ["reporting_person", "location"]  // optional blocks to include by default
}
}

Validation:
\- jurisdiction must be a recognized ISO2 code.
\- field_config is checked against the template-level obligatory goAML fields - exactly rentity_id, submission_code, and currency_code_local (3-letter). Missing fields return a 400 listing exactly which ones, and the template cannot be saved until they are filled in.
\- The remaining report header fields (action, submission_date, at least one transaction, jurisdiction) are per-filing values, enforced later when the REPORT is validated/finalized - not on the template.

Example call:
curl -X POST "https://verification.didit.me/v3/organization/{organization_id}/application/{application_id}/report-templates/" \
-H "x-api-key: YOUR_API_KEY" -H "Content-Type: application/json" \
-d '{"name": "US SAR default", "jurisdiction": "US", "report_type": "SAR", "field_config": {"rentity_id": "FIU-US-00123", "submission_code": "E", "currency_code_local": "USD"}}'

Response 201: ReportTemplateDetail.

Failure modes:
\- 400 - unrecognized jurisdiction, or field_config missing obligatory fields ({"errors": ["rentity_id", ...]}).
\- 401/403 - auth/permission errors (requires write:cases).

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

\</pre>



      
      

Incolla in

Crea un modello di intestazione goAML riutilizzabile. Per essere salvato, un modello deve superare la validazione dei campi obbligatori (`rentity_id`, `submission_code`, `currency_code_local`), sia in fase di creazione sia ogni volta che viene modificato. I campi di intestazione specifici di ogni segnalazione, come `action` e `submission_date`, sono obbligatori quando il report viene validato o finalizzato, non sul modello.## Correlati- [Elenca i modelli di report](https://docs.didit.me/it/management-api/report-templates/list.md)
- [Crea report da un caso](https://docs.didit.me/it/management-api/regulatory-reports/create-for-case.md)


## OpenAPI

````yaml it/openapi-25.json POST /v3/organization/{organization_id}/application/{application_id}/report-templates/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API di verifica dell'identità. Autenticati con l'intestazione x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/organization/{organization_id}/application/{application_id}/report-templates/:
    post:
      tags:
        - Report Templates
      summary: Crea modello di report
      description: >-
        Crea un modello di intestazione goAML riutilizzabile per giurisdizione e
        per tipo di report. Rifiutato con 400 se uno qualsiasi dei campi
        obbligatori a livello di modello (rentity_id, submission_code,
        currency_code_local) manca da field_config; un modello non valido non
        può essere salvato né utilizzato per creare un report. I campi di
        intestazione specifici del deposito (action, submission_date,
        transactions) vengono invece verificati al momento della
        convalida/finalizzazione del report.
      operationId: create_report_template
      parameters:
        - name: organization_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: UUID dell'organizzazione.
        - name: application_id
          in: path
          required: true
          schema:
            type: string
            format: uuid
          description: UUID dell'applicazione.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - name
                - jurisdiction
                - report_type
              properties:
                name:
                  type: string
                jurisdiction:
                  type: string
                  minLength: 2
                  maxLength: 2
                  description: >-
                    Codice paese ISO 3166-1 alpha-2, convertito in maiuscolo al
                    momento del salvataggio.
                report_type:
                  type: string
                  enum:
                    - SAR
                    - STR
                    - CTR
                    - TTR
                    - UTR
                    - IFT
                    - CBR
                    - TFR
                field_config:
                  type: object
                  description: >-
                    Impostazioni predefinite riutilizzabili per l'intestazione
                    goAML. Campi obbligatori a livello di modello: rentity_id,
                    submission_code e currency_code_local (3 lettere).
                    Facoltativi: enabled_fields (quali blocchi di report
                    opzionali includere) oltre ai valori predefiniti per
                    reporting_person, location, reason e action. I campi di
                    intestazione specifici per ogni invio (action,
                    submission_date, transactions, jurisdiction) vengono
                    verificati al momento della validazione o della
                    finalizzazione del report, non sul modello.
            example:
              name: US SAR default
              jurisdiction: US
              report_type: SAR
              field_config:
                rentity_id: FIU-US-00123
                submission_code: E
                currency_code_local: USD
      responses:
        '201':
          description: Modello creato.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ReportTemplateDetail'
        '400':
          description: >-
            Giurisdizione non riconosciuta, oppure field_config non supera la
            validazione dei campi obbligatori.
          content:
            application/json:
              schema:
                type: object
                properties:
                  errors:
                    type: array
                    items:
                      type: string
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: >-
            curl -X POST
            'https://verification.didit.me/v3/organization/11111111-2222-3333-4444-555555555555/application/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee/report-templates/'
            \
              -H 'x-api-key: YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{"name": "US SAR default", "jurisdiction": "US", "report_type": "SAR", "field_config": {"rentity_id": "FIU-US-00123", "submission_code": "E", "currency_code_local": "USD"}}'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            # and DIDIT_APPLICATION_ID.
            client = Didit()

            result = client.report_templates.create(
                name="US SAR default",
                jurisdiction="US",
                report_type="SAR",
                field_config={"rentity_id": "FIU-US-00123", "submission_code": "E", "currency_code_local": "USD"},
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            // and DIDIT_APPLICATION_ID.
            const didit = new Didit();

            const result = await didit.reportTemplates.create({
              name: "US SAR default",
              jurisdiction: "US",
              report_type: "SAR",
              field_config: { rentity_id: "FIU-US-00123", submission_code: "E", currency_code_local: "USD" },
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID\n// and DIDIT_APPLICATION_ID.\nclient := didit.NewClient()\n\nresult, err := client.ReportTemplates.Create(ctx, didit.ReportTemplatesCreateParams{\n\tName:         \"US SAR default\",\n\tJurisdiction: \"US\",\n\tReportType:   \"SAR\",\n\tFieldConfig:  didit.Some(map[string]any{\"rentity_id\": \"FIU-US-00123\", \"submission_code\": \"E\", \"currency_code_local\": \"USD\"}),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.util.Map;

            import me.didit.Didit;

            import me.didit.types.ReportTemplatesCreateParams;


            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID

            // and DIDIT_APPLICATION_ID.

            Didit client = new Didit();


            var result =
            client.reportTemplates().create(ReportTemplatesCreateParams.builder()
                    .name("US SAR default")
                    .jurisdiction("US")
                    .reportType(ReportTemplatesCreateParams.ReportType.of("SAR"))
                    .fieldConfig(Map.of("rentity_id", "FIU-US-00123", "submission_code", "E", "currency_code_local", "USD"))
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;

            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            // and DIDIT_APPLICATION_ID.
            $didit = new DiditClient();

            $result = $didit->reportTemplates->create([
                'name' => 'US SAR default',
                'jurisdiction' => 'US',
                'report_type' => 'SAR',
                'field_config' => ['rentity_id' => 'FIU-US-00123', 'submission_code' => 'E', 'currency_code_local' => 'USD'],
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

            # Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID
            # and DIDIT_APPLICATION_ID.
            didit = Didit::Client.new

            result = didit.report_templates.create(
              name: "US SAR default",
              jurisdiction: "US",
              report_type: "SAR",
              field_config: { rentity_id: "FIU-US-00123", submission_code: "E", currency_code_local: "USD" }
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Collections.Generic;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY, DIDIT_ORGANIZATION_ID

            // and DIDIT_APPLICATION_ID.

            using var client = new DiditClient();


            var result = await client.ReportTemplates.CreateAsync(new
            ReportTemplatesCreateParams

            {
                Name = "US SAR default",
                Jurisdiction = "US",
                ReportType = "SAR",
                FieldConfig = new Dictionary<string, object> { ["rentity_id"] = "FIU-US-00123", ["submission_code"] = "E", ["currency_code_local"] = "USD" },
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    ReportTemplateDetail:
      type: object
      properties:
        uuid:
          type: string
          format: uuid
        name:
          type: string
        jurisdiction:
          type: string
          minLength: 2
          maxLength: 2
          description: Codice paese ISO 3166-1 alpha-2.
        report_type:
          type: string
          enum:
            - SAR
            - STR
            - CTR
            - TTR
            - UTR
            - IFT
            - CBR
            - TFR
        report_type_display:
          type: string
        field_config:
          type: object
          description: >-
            Impostazioni predefinite riutilizzabili per l'intestazione goAML.
            Campi obbligatori a livello di modello: rentity_id, submission_code
            e currency_code_local (3 lettere). Facoltativi: enabled_fields
            (quali blocchi di report opzionali includere) oltre ai valori
            predefiniti per reporting_person, location, reason e action. I campi
            di intestazione specifici per ogni invio (action, submission_date,
            transactions, jurisdiction) vengono verificati al momento della
            validazione o della finalizzazione del report, non sul modello.
        created_at:
          type: string
          format: date-time
        updated_at:
          type: string
          format: date-time
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La chiave API della tua applicazione, da Developers -> API keys nella
        Business Console. La chiave primaria ha accesso completo. Una chiave con
        nome può avere un ambito definito: nessuno, lettura o scrittura per
        risorsa, limitata ad alcuni workflow o a sessioni approvate, a un elenco
        di indirizzi IP e a una data di scadenza. 401 indica che la chiave è
        errata, revocata o scaduta; 403 indica che non è stata inviata alcuna
        chiave, che la chiave non ha accesso a questa risorsa o azione, oppure
        che la richiesta proviene da un indirizzo non incluso nel suo elenco IP;
        404 su una route di sessione indica che la sessione non rientra nei
        workflow o negli stati previsti dalla chiave. Una chiave senza accesso
        ai media riceve gli URL di immagini, video e PDF come null, e una chiave
        senza permessi di scrittura sulle sessioni riceve link e token di
        sessione come null. Consulta https://docs.didit.me/console/api-keys.

````

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