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

# New payment approval

> Initiate an application for using Dintero payments . The application
will contain a link to an URL where the signatory of the account will need
to finish submission of the case contract and sign it. Dintero will perform
a KYC, AML and bank ownership check before the application
`case_status`will be updated to `ACTIVE`. Once the application is approved
we will set up your account for using Dintero payments. Note that not all
payment methods are available in all countries, and that for some payments
methods some processing time must be expected before you can start accepting
payments.

scopes:
- admin:accounts
- write:accounts
- write:accounts:/management/settings/approvals




## OpenAPI

````yaml /mintlify-docs/openapi/spec-payments-v2.yaml post /accounts/{aid}/management/settings/approvals/payments
openapi: 3.0.0
info:
  title: Payments API v2
  contact:
    name: API Integration Support
    email: integration@dintero.com
  description: |
    Public endpoints for payments served under the account-scoped URL format
    `https://api.dintero.com/v1/accounts/{aid}/...`.
  version: LATEST
  license:
    name: UNLICENSED
    url: https://dintero.com
  x-logo:
    url: https://docs.dintero.com/img/dintero-dark-padded.svg
    altText: Dintero Logo
servers:
  - url: https://api.dintero.com/v1
security:
  - JWT: []
tags:
  - name: Transactions
    x-displayName: Transactions
    description: |
      View and perform operations on transactions
  - name: session
    x-displayName: Sessions
    description: |
      A Checkout Session relates to an order in your system.
      When an order has been placed you create a corresponding Checkout Session
      to receive payment for that order.
  - name: payment
    x-displayName: Payment
    description: |
      Resources used by the customer aka user to complete the payment of a
      session.
  - name: settlements
    x-displayName: Settlement reports
    description: Get settlement reports generated per payout
  - name: settlements.configuration
    x-displayName: Configuration
    description: Configure settlement reports
  - name: reports
    x-displayName: Reports
    description: List the generated monthly transaction reports
  - name: Sellers
    x-displayName: Sellers
    description: Manage the signup of a new Seller / Merchant account
  - name: example-session-callbacks
    x-displayName: Example Callbacks
    description: Example of callbacks delivered
  - name: v2-config-payout-destinations
    x-displayName: Sellers
    description: Get payout data for sellers
  - name: Card Tokens
    description: |
      Manage card tokens
  - name: terminals
    x-displayName: Terminals
    description: Terminal operations
  - name: v2-fund-transfers
    x-displayName: Fund transfers
    description: Transfer funds between sellers
  - name: payout-destinations
    x-displayName: payout destinations
    description: |
      Payout destinations
  - name: account-stores
    x-displayName: stores
    description: |
      Manage account stores
  - name: account-terminals
    x-displayName: terminals
    description: |
      Manage account terminals
  - name: report-configuration
    x-displayName: Report configuration
    description: Manage report configurations
  - name: kpi
    x-displayName: KPI
    description: Get KPI data
paths:
  /accounts/{aid}/management/settings/approvals/payments:
    post:
      tags:
        - approvals
      summary: aid_management_settings_approvals_payment_post
      description: >
        Initiate an application for using Dintero payments . The application

        will contain a link to an URL where the signatory of the account will
        need

        to finish submission of the case contract and sign it. Dintero will
        perform

        a KYC, AML and bank ownership check before the application

        `case_status`will be updated to `ACTIVE`. Once the application is
        approved

        we will set up your account for using Dintero payments. Note that not
        all

        payment methods are available in all countries, and that for some
        payments

        methods some processing time must be expected before you can start
        accepting

        payments.


        scopes:

        - admin:accounts

        - write:accounts

        - write:accounts:/management/settings/approvals
      operationId: aid_management_settings_approvals_payment_post
      parameters:
        - $ref: '#/components/parameters/accountId'
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ApprovalsPayment'
        required: true
      responses:
        '200':
          $ref: '#/components/responses/ApprovalsPaymentCreated'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/AccessForbidden'
        '403':
          $ref: '#/components/responses/Forbidden'
        '404':
          $ref: '#/components/responses/NotFound'
        '500':
          $ref: '#/components/responses/ServerError'
      security:
        - JWT: []
components:
  parameters:
    accountId:
      name: aid
      description: |
        An id that uniquely identifies the account.
      in: path
      required: true
      schema:
        type: string
        format: ^[PT]{1}\d{8}$
        minLength: 9
        maxLength: 9
  schemas:
    ApprovalsPayment:
      type: object
      allOf:
        - $ref: '#/components/schemas/Entity'
        - required:
            - country_code
            - organization_number
            - bank_accounts
            - payment_methods
            - products
          properties:
            type:
              type: string
              description: >
                The kind of application the approval is for. Decides which

                declaration form the signatory is presented with.


                - `ecommerce`: online payments only.

                - `in_person`: in-person payments only.

                - `multi_channel`: both online and in-person payments.

                - `in_person_upsell`: in-person payments added to an account
                that is
                  already approved for online payments.

                When omitted, the type is derived from `payment_methods`:

                `in_person` when only `ipp` is present, `ecommerce` when `ipp`
                is

                absent, and `multi_channel` when both are present.
              enum:
                - ecommerce
                - in_person
                - multi_channel
                - in_person_upsell
            products:
              type: array
              items:
                type: object
                required:
                  - product
                properties:
                  product:
                    $ref: '#/components/schemas/ApprovalsPaymentProduct'
            payment_methods:
              description: |
                Payment methods that the merchant wants to accept.
              type: array
              items:
                type: object
                required:
                  - payment_method
                properties:
                  payment_method:
                    type: string
                    enum:
                      - creditcard
                      - applepay
                      - clicktopay
                      - vipps
                      - swish
                      - mobilepay
                      - klarna
                      - walley
                      - santander
                      - netaxept
                      - instabank
                      - googlepay
                      - billie
                      - kravia
                      - two
                      - ipp
            country_code:
              type: string
              format: iso-3166-1
              description: >
                Country code, must be a two letter ISO 3166-1-alpha-2 country
                code
              maxLength: 2
              minLength: 2
            organization_number:
              type: string
              description: |
                National organization number valid in the country specified.
            bank_accounts:
              type: array
              minItems: 1
              maxItems: 1
              description: |
                Bank account information about the seller. Currently
                the contract service only supports one bank_account per payout
                destination.
              items:
                $ref: '#/components/schemas/ApprovalsBankAccount'
            form_submitter:
              type: object
              description: >
                The user that will submit the form. If the email is set the user
                will be notified

                about the form via email.


                See [Seller onboarding - Reminder
                emails](https://docs.dintero.com/docs/checkout/split-payment/add-payout-destinations#reminder-emails)

                for the reminder schedule.
              properties:
                email:
                  type: string
                  format: email
                  description: |
                    The email of the user that will submit the form.
                name:
                  type: string
                  description: |
                    The name of the user that will submit the form.
                title:
                  type: string
                  description: |
                    The title of the user that will submit the form.
    Entity:
      type: object
      properties:
        id:
          type: string
          format: uuid
          description: |
            An UUID that uniquely identifies the resource
          readOnly: true
        created_at:
          type: string
          format: date-time
          description: |
            The date-time when the resource was created
          readOnly: true
        created_by:
          type: string
          example: 1c92f7e1-2897-4d46-bdcc-c127a914fb4e
          description: |
            The ID of the user/client created the resource
          readOnly: true
        updated_at:
          type: string
          format: date-time
          description: |
            The date-time when the resource was last updated
          readOnly: true
        deleted_by:
          type: string
          example: 1c92f7e1-2897-4d46-bdcc-c127a914fb4e
          description: |
            The ID of the user/client created the resource
          readOnly: true
        deleted_at:
          type: string
          format: date-time
          readOnly: true
    ApprovalsPaymentProduct:
      type: string
      description: |
        The type of product that the merchant wants to use for their business.
         - `checkout` the merchant accepts payouts to a single bank account
           (per currency).
         - `split_payment` needed for partners, marketplaces and platforms that
           will onboard sellers that will receive payouts to the sellers' own bank
           accounts.
      enum:
        - checkout
        - split_payment
    ApprovalsBankAccount:
      type: object
      required:
        - bank_account_currency
        - payout_currency
      properties:
        bank_name:
          type: string
          description: Name of the Bank used
        bank_account_number:
          type: string
          description: BBAN, national bank account number
        bank_account_number_type:
          type: string
          enum:
            - IBAN
            - BBAN
          description: >
            The type of bank account number. Will default to BBAN in
            bank_country_code

            is norwegian. Will default to IBAN in all other countries.
        bank_account_country_code:
          $ref: '#/components/schemas/BankAccountCountryCode'
        bank_account_currency:
          type: string
          format: iso4217-code
          example: NOK
          description: |
            The three-character ISO-4217 currency.
            https://en.wikipedia.org/wiki/ISO_4217
        payout_currency:
          type: string
          format: iso4217-code
          example: NOK
          description: |
            The three-character ISO-4217 currency.
            https://en.wikipedia.org/wiki/ISO_4217
        bank_identification_code:
          type: string
          example: DNBANOKKXXX
          description: >
            A BIC code, or Bank Identifier Code also know as SWIFT code,
            consistin of

            8 to 11 alphanumeric characters.
    ApprovalsPaymentResponse:
      type: object
      allOf:
        - $ref: '#/components/schemas/ApprovalsPayment'
        - properties:
            case_status:
              $ref: '#/components/schemas/ApprovalStatus'
            links:
              $ref: '#/components/schemas/ApprovalLinks'
            mcc:
              type: string
              format: iso-18245
              example: 5814
              description: |
                A four-digit Merchant Category Code (MCC) for the store
                [ISO 18245:2003](https://www.iso.org/standard/33365.html)

                The MCC set on the case
    Error:
      type: object
      required:
        - error
      properties:
        error:
          type: object
          required:
            - message
          properties:
            code:
              type: string
              description: The code used to identify the error/warning
            errors:
              type: array
              description: The nested error(s) encountered during validation
              items:
                type: object
            message:
              type: string
              description: The human readable description of the error/warning
    BankAccountCountryCode:
      type: string
      description: |
        Which country the bank account is registered in.
        Must be a two letter ISO 3166-1-alpha-2 country code.

        Supported bank account country codes:
          * `AT` (Austria)
          * `BE` (Belgium)
          * `HR` (Croatia)
          * `CY` (Cyprus)
          * `DK` (Denmark)
          * `EE` (Estonia)
          * `FI` (Finland)
          * `FR` (France)
          * `DE` (Germany)
          * `GR` (Greece)
          * `IE` (Ireland)
          * `IS` (Iceland)
          * `IT` (Italy)
          * `LV` (Latvia)
          * `LT` (Lithuania)
          * `LU` (Luxembourg)
          * `MT` (Malta)
          * `NL` (Netherlands)
          * `NO` (Norway)
          * `PT` (Portugal)
          * `SK` (Slovakia)
          * `SI` (Slovenia)
          * `ES` (Spain)
          * `SE` (Sweden)
          * `UK` (United Kingdoms)
          * `US` (United States of America)
      maxLength: 2
      minLength: 2
      pattern: ^[A-Z]{2}$
      example: 'NO'
    ApprovalStatus:
      type: string
      enum:
        - ACTIVE
        - DECLINED
        - UNDER_MANUAL_REVIEW
        - AUTOMATIC_REVIEW
        - WAITING_FOR_SIGNATURE
        - WAITING_FOR_DECLARATION
        - ERROR
        - ARCHIVED
        - WAITING_FOR_DETAILS
        - TERMINATED
    ApprovalLinks:
      type: array
      items:
        type: object
        properties:
          href:
            type: string
            description: The URL of the link.
            format: uri
          rel:
            type: string
            description: |
              Specifies the type of link
            enum:
              - contract_url
              - cdd_case_url
              - dintero_cdd_case_url
              - declaration_url
              - signed_contract_file_url
  responses:
    ApprovalsPaymentCreated:
      description: Created ApprovalsPaymentResponse
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApprovalsPaymentResponse'
    BadRequest:
      description: Bad / Invalid request
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    AccessForbidden:
      description: Access forbidden, invalid JWT token was used
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    Forbidden:
      description: Forbidden
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    NotFound:
      description: Resource was not found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    ServerError:
      description: Unexpected Error
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
  securitySchemes:
    JWT:
      type: http
      description: >
        Bearer authentication (token authentication) should be used for
        accessing the API.


        Use [Get Token](/api-reference/authenticate/aid_auths_oauth_token_post)
        to get an access token for client credentials.

        Pass the token in the request header:

            Authorization: Bearer {access_token}

        where the **access_token** is JSON Web Tokens (JWT).
      scheme: bearer
      bearerFormat: JWT

````

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