Bancomat Chain API

Questo endpoint consente di concatenare i pagamenti tra diversi documenti, automatizzando il pagamento di una fattura utilizzando l'importo ricevuto da un'altra fattura attiva. Nota: L'API per questo endpoint non richiede scopi specifici; il token di autorizzazione utilizzato deve avere accesso ai documenti da pagare. Il processo della catena di pagamento funziona collegando un documento "ring" che collega un documento di attivazione a un documento di destinazione. Una volta creato il documento ring, esso stabilisce una connessione tra il documento di attivazione, che avvia la catena di pagamento, e il documento di destinazione, che riceverà il pagamento una volta che il documento di attivazione è stato pagato tramite FlowPay. Ad esempio, supponiamo che ci siano due documenti. Il primo documento riguarda un pagamento che l'azienda A deve effettuare all'azienda B, mentre il secondo documento riguarda un pagamento che l'azienda B deve effettuare all'azienda C. Per automatizzare questi pagamenti, l'azienda B crea un "anello" utilizzando il suo token di autorizzazione. Questo anello collega il primo documento come "trigger" (documento di attivazione) e il secondo documento come "target" (documento di destinazione). Una volta creato l'anello, è possibile generare sessioni di checkout per ciascun documento. Il checkout per il documento di attivazione procede come un processo di pagamento standard, mentre il checkout per il documento di destinazione viene creato con un tipo di catena. Questo tipo di checkout a catena per il documento di destinazione non richiede un pagamento immediato, ma attende il pagamento del documento di attivazione. Quando l'azienda B accede e completa il checkout per il documento di destinazione, non viene effettuato alcun pagamento. Tuttavia, quando il documento di attivazione viene pagato, si attiva automaticamente il pagamento del documento di destinazione. Se c'è un importo residuo dopo il pagamento del documento di destinazione, l'azienda B lo riceverà. In questo modo, l'automazione dei pagamenti assicura che tutti i documenti coinvolti siano regolati in modo sequenziale, utilizzando i fondi ricevuti da un documento attivo per pagare un altro documento in sospeso, riducendo al minimo l'intervento manuale e semplificando la gestione dei flussi di cassa tra le aziende coinvolte. ### Utilizzo della catena di pagamento per il pagamento frazionato In uno scenario di pagamento frazionato, la catena di pagamento può essere utilizzata per distribuire automaticamente i fondi tra più parti, anche trattenendo una parte del pagamento per il partner prima di inoltrare l'importo rimanente al creditore. Ad esempio, supponiamo che l'azienda A debba pagare l'azienda B, ma che una parte del pagamento sia trattenuta dall'azienda C (che agisce come partner o intermediario). L'azienda A crea un documento di attivazione che rappresenta il pagamento che deve all'azienda B. Viene quindi creato un documento ring che collega questo documento di attivazione a due documenti di destinazione: uno per l'azienda B e uno per l'azienda C. Quando l'azienda A effettua il pagamento, la catena di pagamento assicura che i fondi vengano prima instradati attraverso l'azienda C. La parte a cui l'azienda C ha diritto (come concordato) viene trattenuta, mentre il resto del pagamento viene automaticamente inoltrato all'azienda B. Questa configurazione assicura che il pagamento frazionato venga gestito senza problemi, con un intervento manuale minimo, e che tutte le parti ricevano gli importi dovuti secondo le regole predefinite della catena di pagamento.

Operations 6

GET /{tenantID}/chain Get by tenant id chain #
POST /{tenantID}/chain Create by tenant id chain #
GET /{tenantID}/chain/{fingerprint} Get document details #
POST /chain Create chain document #
GET /chain List chain documents #
GET /chain/{fingerprint} Get document details #

Work with this as data

Every API here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for apis

7 MCP tools reach this
  • find_apisBrowse and filter every API in the catalog.
  • get_api_artifactsOne API's artifacts, grouped by type.
  • get_openapiThe primary OpenAPI for this API.
  • find_similar_apisAPIs that look like this one.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This API
curl "https://apis.io/api/v1/apis/bancomat-chain-api"
All apis
curl "https://apis.io/api/v1/apis?limit=25"

Discovery needs no key. Ratings and market analysis are Pro.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.

OpenAPI Specification

bancomat-chain-api-openapi.yml Raw ↑
openapi: 3.2.0
info:
  title: Bancomat Chain API
  x-refined-note:
  - x-json-schema-faker differs across the merged source definitions and was not carried
  - x-logo differs across the merged source definitions and was not carried
  version: '1.0'
  description: 'Operations tagged Chain across 2 of this provider''s published API definitions: bancomat-flowpay-api-v1-openapi.json, bancomat-flowpay-api-v2-openapi.json. Each path carries the servers of the definition it was published in.'
servers:
- url: https://app.flowpay.it/api
  variables: {}
- url: https://api.flowpay.it/v2
  description: Production server (Not implementend)
- url: https://mock.flowpay.it/v2
  description: Mock server
- url: https://sandbox.{customerID}.flowpay.it/v2
  description: Customer-assigned sandbox server
  variables:
    customerID:
      default: 00000000-00000000-00000000-00000000
      description: Unique customer identifier assigned after contract signature
- url: http://localhost:5002
  description: Debug
tags:
- description: Questo endpoint consente di concatenare i pagamenti tra diversi documenti, automatizzando il pagamento di una fattura utilizzando l'importo ricevuto da un'altra fattura attiva.
  name: Chain
paths:
  /{tenantID}/chain:
    get:
      description: Recupera la lista dei documenti di tipo chain
      parameters:
      - description: ID dell'owner della richiesta
        example: 84461172-4326-4D6B-AEA7-840ED1372200
        in: path
        name: tenantID
        required: true
        schema:
          example: 84461172-4326-4D6B-AEA7-840ED1372200
          format: uuid
          type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                items:
                  $ref: '#/components/schemas/Chain'
                type: array
          description: Chain payments list
        '400':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: La richiesta non è corretta sintatticamente, body, headers, path o query params non conformi alla documentazione
        '401':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: Le credenziali fornite non sono sufficienti a completare la richiesta
        '403':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: La richiesta non è autorizzata a procedere con le credenziali fornite
        '404':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: La richiesta fa riferimento ad una risorsa inesistente
      security:
      - ThirdPartyClientCredential: []
      - ThirdPartyAuthorizationCode: []
      tags:
      - Chain
      summary: Get by tenant id chain
      x-summary-source: derived
      operationId: getByTenantIDChain
      x-operation-id-source: derived
    post:
      description: Crea un nuvo document chain. Specificando la fingerprint del documento che verra pagato e di quello che triggera il pagamento, insieme ai loro tipi.
      parameters:
      - description: ID dell'owner della richiesta
        example: 84461172-4326-4D6B-AEA7-840ED1372200
        in: path
        name: tenantID
        required: true
        schema:
          example: 84461172-4326-4D6B-AEA7-840ED1372200
          format: uuid
          type: string
      requestBody:
        content:
          application/json:
            schema:
              properties:
                targetFingerprint:
                  $ref: '#/components/schemas/Fingerprint'
                targetType:
                  $ref: '#/components/schemas/DocumentKindEnum'
                triggerFingerprint:
                  $ref: '#/components/schemas/Fingerprint'
                triggerType:
                  $ref: '#/components/schemas/DocumentKindEnum'
              required:
              - triggerType
              - triggerFingerprint
              - targetType
              - targetFingerprint
              type: object
      responses:
        '201':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Chain'
          description: Chain payment created
        '400':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: La richiesta non è corretta sintatticamente, body, headers, path o query params non conformi alla documentazione
        '401':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: Le credenziali fornite non sono sufficienti a completare la richiesta
        '403':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: La richiesta non è autorizzata a procedere con le credenziali fornite
        '404':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: La richiesta fa riferimento ad una risorsa inesistente
      security:
      - ThirdPartyClientCredential: []
      - ThirdPartyAuthorizationCode: []
      tags:
      - Chain
      summary: Create by tenant id chain
      x-summary-source: derived
      operationId: postByTenantIDChain
      x-operation-id-source: derived
    servers:
    - url: https://app.flowpay.it/api
      variables: {}
  /{tenantID}/chain/{fingerprint}:
    get:
      description: Restituisce le informazioni relative a uno specifico documento di tipo chain
      parameters:
      - description: ID dell'owner della richiesta
        example: 84461172-4326-4D6B-AEA7-840ED1372200
        in: path
        name: tenantID
        required: true
        schema:
          example: 84461172-4326-4D6B-AEA7-840ED1372200
          format: uuid
          type: string
      - in: path
        name: fingerprint
        required: true
        schema:
          type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Chain'
          description: Chain payment details
        '400':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: La richiesta non è corretta sintatticamente, body, headers, path o query params non conformi alla documentazione
        '401':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: Le credenziali fornite non sono sufficienti a completare la richiesta
        '403':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: La richiesta non è autorizzata a procedere con le credenziali fornite
        '404':
          content:
            application/json; charset=utf-8:
              example:
                code: 12345678
                errorDescription: hello
                errorURI: null
                expectedType: null
                field: null
                requestID: null
                service: 12345678
                statusCode: 12345678
              schema:
                $ref: '#/components/schemas/ErrorDTO'
          description: La richiesta fa riferimento ad una risorsa inesistente
      security:
      - ThirdPartyClientCredential: []
      - ThirdPartyAuthorizationCode: []
      summary: Get document details
      tags:
      - Chain
      operationId: getByTenantIDChainByFingerprint
      x-operation-id-source: derived
    servers:
    - url: https://app.flowpay.it/api
      variables: {}
  /chain:
    post:
      summary: Create chain document
      description: Create a new chain document. This endpoint allows to specify the fingerprint of the document that will be paid and the trigger document for that payment, along with their type.
      operationId: createChainPayment
      security:
      - oAuth2: []
      tags:
      - Chain
      requestBody:
        description: Dictionary of fingerprints to be linked to the bulk payment, each property name is the document type.
        content:
          application/json:
            schema:
              type: object
              properties:
                triggerType:
                  $ref: '#/components/schemas/DocumentKindEnum_2'
                triggerFingerprint:
                  $ref: '#/components/schemas/Fingerprint_2'
                targetType:
                  $ref: '#/components/schemas/DocumentKindEnum_2'
                targetFingerprint:
                  $ref: '#/components/schemas/Fingerprint_2'
              required:
              - triggerType
              - triggerFingerprint
              - targetType
              - targetFingerprint
      responses:
        '201':
          description: Chain payment created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Chain'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '500':
          $ref: '#/components/responses/InternalServerError'
    get:
      summary: List chain documents
      description: 'List all chain documents according to the specified filters.

        Returns a paginated list of chain documents.'
      operationId: listChainPayments
      security:
      - oAuth2: []
      tags:
      - Chain
      parameters:
      - name: page
        in: query
        description: Page number
        required: false
        schema:
          type: integer
          format: int32
          minimum: 1
        x-faker: random.number
        x-fakerParams:
        - min: 1
      - name: pageSize
        in: query
        description: Page size
        required: false
        schema:
          type: integer
          format: int32
          minimum: 1
          maximum: 100
        x-faker: random.number
        x-fakerParams:
        - min: 1
          max: 100
      responses:
        '200':
          description: Chain payments list
          content:
            application/json:
              schema:
                allOf:
                - $ref: '#/components/schemas/PaginatedResult'
                - type: object
                  properties:
                    items:
                      type: array
                      items:
                        $ref: '#/components/schemas/Chain'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '500':
          $ref: '#/components/responses/InternalServerError'
    servers:
    - url: https://api.flowpay.it/v2
      description: Production server (Not implementend)
    - url: https://mock.flowpay.it/v2
      description: Mock server
    - url: https://sandbox.{customerID}.flowpay.it/v2
      description: Customer-assigned sandbox server
      variables:
        customerID:
          default: 00000000-00000000-00000000-00000000
          description: Unique customer identifier assigned after contract signature
    - url: http://localhost:5002
      description: Debug
  /chain/{fingerprint}:
    get:
      summary: Get document details
      description: Get bulk document details by ID
      operationId: getChainPayment
      security:
      - oAuth2: []
      tags:
      - Chain
      parameters:
      - name: fingerprint
        in: path
        description: Chain payment fingerprint
        required: true
        schema:
          $ref: '#/components/schemas/Fingerprint_2'
        x-faker: datatype.uuid
      responses:
        '200':
          description: Chain payment details
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Chain'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'
        '500':
          $ref: '#/components/responses/InternalServerError'
    servers:
    - url: https://api.flowpay.it/v2
      description: Production server (Not implementend)
    - url: https://mock.flowpay.it/v2
      description: Mock server
    - url: https://sandbox.{customerID}.flowpay.it/v2
      description: Customer-assigned sandbox server
      variables:
        customerID:
          default: 00000000-00000000-00000000-00000000
          description: Unique customer identifier assigned after contract signature
    - url: http://localhost:5002
      description: Debug
components:
  schemas:
    DocumentKindEnum:
      enum:
      - bill
      - bulk
      - chain
      - construction
      - invoice
      - pagopa
      - transfer
      type: string
    ErrorDTO:
      description: "Formato errore standard\n    \nLista dei possibili codici di errore:\n\n| codice | descrizione |\n| ------ | ----------- |\n| 401 | Errore generale di codifica |\n| 402 | Campo necessario mancante |\n| 403 | Valore di un campo del tipo sbagliato |\n| 404 | Valore di un campo assente |\n| 405 | Errore di codifica sconosciuto |\n| 406 | Null pointer exception |\n| 407 | Campo necessario mancante |\n| 408 | Errore di connessione |\n| 409 | Errore di input output |\n| 410 - 428 | Errore generico con il database |\n| 429, 432, 433 | Errore di logica con il database |\n| 430 | Campo invalido |\n| 431 | Campo assente |\n| 434 | Risultati non trovati |\n| 500 | Errore generico |\n| 2000 | Tenant non specificato |\n| 2001 | Non autorizzato ad operare su questa risorsa |\n| 2002 | Impossibile eliminare il documento poiché sono presente dei pagamenti collegati |\n| 2003 | Non autorizzato a creare la risorsa |\n| 2004 | Non autorizzato ad operare su questa risorsa |\n| 2005 | Si sta provando a modificare un termine non di questo documento |\n| 2006 | Codice istant scaduto |\n| 2007 | Non autorizzato generare un codice instant |\n| 2008 | Codice instant inesistente o non autorizzato a leggerlo |\n| 2012 | Si sta provando a caricare un documento già esistente |\n| 3001 | Tenant non specificato |\n| 4001 | Tenant non specificato |\n| 5001 | Corpo richiesta mancante |\n| 5002 | Corpo richiesta non valido |\n| 5003 | Vatcode del ricevente fattura mancante |\n| 6001 | Tenant non specificato |\n| 6002 | Ricevuta non trovata |\n| 8005 | Non puoi modificare questo conto |\n| 8010 | Troppi risultati ottenuti |\n| 11001 | Non autorizzato ad accedere a questa risorsa |\n| 11002 | Si sta provando a caricare un documento già esistente |\n| 13001 | Azienda non trovata |\n| 13003 | vatcode non è valido |"
      properties:
        code:
          description: Codice errore
          example: '12345678'
          format: int64
          type: integer
        errorDescription:
          description: Descrizione errore
          example: string
          type: string
        errorURI:
          description: URI dell'errore se presente
          example: string
          type: string
        expectedType:
          description: Nel caso di un errore di codifica indica il tipo di dato che non si è riuscito a decodificare
          example: string
          type: string
        field:
          description: Nel caso di un errore di codifica indica il campo che non si è riuscito a decodificare
          example: string
          type: string
        requestID:
          description: ID della richiesta da comunicare per poter fornire un supporto
          example: string
          type: string
        service:
          description: ID interno del servizio
          example: '12345678'
          format: int64
          type: integer
        statusCode:
          description: Codice di stato HTTP
          example: '12345678'
          format: int64
          type: integer
      required:
      - service
      - code
      - errorDescription
      - statusCode
      type: object
    Chain:
      description: Chain of documents
      properties:
        fingerprint:
          $ref: '#/components/schemas/Fingerprint'
        targetFingerprint:
          $ref: '#/components/schemas/Fingerprint'
        targetType:
          $ref: '#/components/schemas/DocumentKindEnum'
        triggerFingerprint:
          $ref: '#/components/schemas/Fingerprint'
        triggerType:
          $ref: '#/components/schemas/DocumentKindEnum'
      type: object
    Fingerprint:
      description: Fingerprint del documento
      example: d41d8cd98f00b204e9800998ecf8427e
      type: string
    DocumentKindEnum_2:
      type: string
      enum:
      - bill
      - bulk
      - chain
      - construction
      - invoice
      - pagopa
      - transfer
      description:
        $ref: types/DocumentKind.md
    PaginatedResult:
      type: object
      properties:
        page:
          type: integer
          description: Current page number
        pageSize:
          type: integer
          description: Number of items per page
        total:
          type: integer
          description: Total number of items
        items:
          type: array
          description: List of items
          items: {}
    RequestID:
      type: string
      description: Unique identifier of the request.<br> It is helpful to identify the request in case of errors, providing it to the support team. Please submit it in the support ticket.
      format: uuid
      x-faker: random.uuid
    StatusCode:
      type: integer
      description: HTTP status code
      example: 404
    Fingerprint_2:
      type: string
      description: Fingerprint of the document
      example: d41d8cd98f00b204e9800998ecf8427e
  responses:
    InternalServerError:
      description: Server encountered an unexpected condition that prevented it from fulfilling the request
      content:
        application/json:
          schema:
            type: object
            properties:
              statusCode:
                $ref: '#/components/schemas/StatusCode'
              requestID:
                $ref: '#/components/schemas/RequestID'
            required:
            - statusCode
            - requestID
    NotFound:
      description: The requested resource was not found
      content:
        application/json:
          schema:
            type: object
            properties:
              statusCode:
                $ref: '#/components/schemas/StatusCode'
              requestID:
                $ref: '#/components/schemas/RequestID'
              message:
                type: string
                description: Error message
                example: Invoice not found
            required:
            - statusCode
            - requestID
            - message
    Unauthorized:
      description: Client has not provided valid credentials to access the requested resource
      content:
        application/json:
          schema:
            type: object
            properties:
              statusCode:
                $ref: '#/components/schemas/StatusCode'
              requestID:
                $ref: '#/components/schemas/RequestID'
              message:
                type: string
                description: Error message
                example: You must provide a valid access token
            required:
            - statusCode
            - requestID
            - message
    BadRequest:
      description: Client has provided invalid data
      content:
        application/json:
          schema:
            type: object
            properties:
              statusCode:
                $ref: '#/components/schemas/StatusCode'
              requestID:
                $ref: '#/components/schemas/RequestID'
              message:
                type: string
                description: Error message
                example: Proforma invoice can not have a due date later than the invoice date
              additionalInfo:
                type: object
                description: Additional information about the error
                properties:
                  path:
                    type: string
                    description: JSON path of the field that caused the error
                    example: .dueDate
                  key:
                    type: string
                    description: JSON key of the field that caused the error
                    example: dueDate
                  type:
                    type: string
                    description: Expected type of the field that caused the error
                    example: string
                required:
                - path
            required:
            - statusCode
            - requestID
            - message
            - additionalInfo
    Forbidden:
      description: Client is not authorized to access the requested resource
      content:
        application/json:
          schema:
            type: object
            properties:
              statusCode:
                $ref: '#/components/schemas/StatusCode'
              requestID:
                $ref: '#/components/schemas/RequestID'
              message:
                type: string
                description: Error message
                example: You can't create a new invoice for this tenant
            required:
            - statusCode
            - requestID
            - message
  securitySchemes:
    ThirdPartyAuthorizationCode:
      description: Autorizzazione oauth ottenuta da terze parti con un authorization flow
      flows:
        authorizationCode:
          authorizationUrl: https://core.flowpay.it/api/openid/authenticate
          refreshUrl: https://core.flowpay.it/api/oauth/token
          scopes:
            account:read: Operazioni di lettura sui conti
            bill:write: Creazione e gestione di ricevute
            business:read: Operazioni di lettura sulle informazioni della azienda
            contacts:read: Operazioni di lettura sulla rete aziendale
            invoice:read: Operazioni di lettura sulle fatture
            invoice:write: Operazioni di scrittura sulle fatture
            payment:read: Operazioni di lettura sui pagamenti
            salary:read: Operazioni di lettura sulle buste paga
            salary:write: Operazioni di scrittura sui salary
            statistic:read: Lettura dei dati statistici raggruppati
            transfer:read: Operazioni di lettura sui trasferimenti
            transfer:write: Operazioni di scrittura sui trasferimenti
          tokenUrl: https://core.flowpay.it/api/oauth/token
      type: oauth2
    ThirdPartyClientCredential:
      description: Autorizzazione oauth ottenuta da terze parti con client credential flow
      flows:
        clientCredentials:
          refreshUrl: https://core.flowpay.it/api/oauth/token
          scopes:
            account:read: Operazioni di lettura sui conti
            account:write: Operazione di modifica sui conti
            authorization_intent: Creazione di intenti a consensi relativi a risorse di un utente
            bill: Gestione di ricevute
            business:read: Operazioni di lettura sulle informazioni della azienda
            invoice:read: Operazioni di lettura sulle fatture
            invoice:write: Operazioni di scrittura sulle fatture
            pagopa: ''
            payment:read: Operazioni di lettura sui pagamenti
            salary:read: Operazioni di lettura sulle buste paga
            salary:write: Operazioni di scrittura sui salary
            statistic:read: Lettura dei dati statistici raggruppati
            transfer:read: ''
            transfer:write: ''
          tokenUrl: https://core.flowpay.it/api/oauth/token
      type: oauth2
    oAuth2:
      type: oauth2
      description: OAuth2 flow
      flows:
        authorizationCode:
          authorizationUrl: /openid/authenticate
          tokenUrl: /oauth/token
          refreshUrl: /oauth/token
          scopes:
            accounts:read: Allow to read accounts
            accounts:write: Allow to mediate accounts creation and open banking consent renewal
            invoices:read: Allow to read invoices
            invoices:write: Allow to create invoices and manage lifecycle
            bills:read: Allow to read bills
            bills:write: Allow to create bills and manage lifecycle
            constructions:read: Allow to read information about construction sites
            constructions:write: Allow to create construction sites and manage the lifecycle
            openid: Allow to read user profile
            pagopa:read: Allow to retrieve users' PagoPA payment notices
            pagopa:write: Allow to create PagoPA payment notices
            transfers:read: Allow to read transfers
            transfers:write: Allow to create transfers and manage lifecycle
            wallet:`document_type`: Allow to manage wallet for the specified use case
        clientCredentials:
          tokenUrl: /oauth/token
          scopes:
            ade: Allow to interact with Agenzia delle Entrate services
            accounts:read: Allow to read accounts
            accounts:write: Allow to mediate accounts creation and open banking consent renewal
            invoices:read: Allow to read invoices
            invoices:write: Allow to create invoices and manage lifecycle
            bills:read: Allow to read bills
            bills:write: Allow to create bills and manage lifecycle
            constructions:read: Allow to read information about construction sites
            constructions:write: Allow to create construction sites and manage the lifecycle
            openid: Allow to read user profile
            pagopa:read: Allow to retrieve users' PagoPA payment notices
            pagopa:write: Allow to create PagoPA payment notices
            transfers:read: Allow to read transfers
            transfers:write: Allow to create transfers and manage lifecycle
            wallet:`document_type`: Allow to manage wallet for the specified use case
x-refined-from:
- bancomat-flowpay-api-v1-openapi.json
- bancomat-flowpay-api-v2-openapi.json