> ## 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 de comprovació de comptes bancaris de pagament

> Comprova amb Didit que un compte bancari pertany a la persona o empresa que indiquis, abans d'enviar-hi diners. Sense sessió ni inici de sessió.

> [!NOTE]
>
> En producció, la comprovació del compte s'executa a Nigèria, Ghana i Kenya.
> Un altre país respon amb `404` i `code: country_not_covered` i no es factura.
> Més països s'obriran amb el temps, i [preus de Verificació bancària](https://docs.didit.me/ca/getting-started/bank-verification-pricing.md) mostren sempre el que ofereix cada país avui.

El teu backend envia el nom i el compte, i llegeix el resultat. És la [comprovació del compte](https://docs.didit.me/ca/core-technology/bank-verification/account-check.md) del pas de Verificació bancària, sense la persona.

## Envia el compte com l'escriu el seu país

| País | `account` |
| - | - |
| Països IBAN | `{"iban": "..."}` |
| Regne Unit | `{"sort_code": "...", "account_number": "..."}` |
| Estats Units | `{"routing_number": "...", "account_number": "..."}` |
| Canadà | `{"transit_institution": "...", "account_number": "..."}` |
| Austràlia | `{"bsb": "...", "account_number": "..."}` |
| Índia | `{"ifsc": "...", "account_number": "..."}` |
| Nigèria | `{"bank_code": "...", "account_number": "..."}`, amb el codi NIP de 6 dígits del banc (Access Bank és `000014`) i el NUBAN de 10 dígits |
| Ghana | `{"bank_code": "...", "account_number": "..."}`, amb el codi de 3 lletres del banc (GCB Bank és `GCB`) |
| Kenya | `{"bank_code": "...", "account_number": "..."}`, amb el codi de 2 dígits del banc (KCB és `01`) |
| Mèxic | `{"clabe": "..."}` |
| Argentina | `{"cbu_cvu": "..."}` |

Alguns països també demanen un `bic`, i per a un compte d'empresa un `registration_id`. Els espais, els guions i els punts s'ignoren. Si falta una clau que necessita la comprovació del compte, es retorna un `400` que l'especifica, per exemple `"field": "account.bank_code", "reason": "required"`.

Envia `holder.full_name` per comprovar el compte d'una persona, o `holder.business_name` per comprovar el d'una empresa.

## Envia el consentiment del titular del compte

En alguns països, la comprovació del compte necessita el consentiment explícit del titular del compte abans de cada comprovació.
Demana'l dins del teu producte i després envia `"consent": true`.
Sense ell, una comprovació en aquests països es rebutja amb un `400` (`field: consent`, `reason: required`) i no es factura.
A la resta de països, `consent` és opcional, i quan l'envies Didit el registra amb el càrrec de la comprovació.
Una clau de sandbox demana consentiment en els mateixos països que una clau de producció.

## Llegeix el resultat

| `result` | Què significa | Pas següent habitual |
| - | - | - |
| `match` | El banc té el compte amb el nom que has enviat. | Envia els diners. |
| `close_match` | El banc té el compte amb un nom semblant. `holder_name` és aquest nom, si el banc l'ha retornat. | Compara `holder_name`, o demana a la persona que ho confirmi. |
| `no_match` | El banc té el compte a nom d'un altre titular, o no hi ha cap compte així. | No enviïs els diners. |
| `cannot_verify` | El banc ha respost sense comparar el nom, per exemple per a un compte bloquejat o tancat. | Aplica la teva pròpia política, per exemple demana un altre compte. |

## Facturació i reintents

Cada comprovació a la qual respon el banc es factura una vegada al [Preu de la comprovació del compte](https://docs.didit.me/ca/getting-started/bank-verification-pricing.md) del país del compte, sigui quin sigui el resultat. Una sol·licitud que rep un error no es factura mai: un cos rebutjat (`400`), sense crèdit (`402`), un compte per al qual encara no s'ofereix cap comprovació (`404`) o un banc que no ha pogut respondre (`503`).

No hi ha clau d'idempotència ni endpoint per consultar una comprovació un cop feta. Una sol·licitud reintentada executa una comprovació nova, amb un `request_id` nou, i es factura de nou, així que desa la resposta. Didit només guarda el càrrec, amb l'ID de la sol·licitud, el país, el resultat i el compte emmascarat, mai el nom ni el número de compte complet.

## Prova-ho al sandbox

Una clau d'API de sandbox no crida cap banc i no es cobra res. Els 4 últims caràcters de l'IBAN, o si no del número de compte, determinen la resposta:

| Acaba en | Resposta |
| - | - |
| `0001` | `close_match`, amb un `holder_name` |
| `0002` | `close_match`, `holder_name: null` |
| `0003`, `0006` | `no_match` |
| `0004` | `cannot_verify` |
| `0005` | `503`, `account_check_unavailable` |
| `0009` | `400`, `reason: rejected` |
| Qualsevol altra cosa | `match` |

Un IBAN, un CLABE i un CBU porten dígits de control: fes servir els [valors de sandbox](https://docs.didit.me/ca/core-technology/bank-verification/account-check.md#prova-ho-en-sandbox) que superen totes les comprovacions de format.

## Accés

Autentica't amb la `x-api-key` de la teva aplicació, o amb el seu token portador de credencials de client. Una clau d'API amb àmbit necessita accés d'escriptura a les sessions. L'endpoint comparteix el límit d'escriptura de 300 sol·licituds per minut per clau d'API.


## OpenAPI

````yaml ca/openapi-25.json POST /v3/bank/account-check/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API de verificació d'identitat. Autentica't amb la capçalera x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/bank/account-check/:
    post:
      tags:
        - Standalone APIs
      summary: Comprovar un compte bancari
      description: >-
        Comprova que un compte bancari pertany a la persona o empresa que
        indiques, abans d'enviar-hi diners. Sense sessió i sense inici de
        sessió: envia el nom i el compte, i llegeix el resultat. És la
        [comprovació de
        compte](/ca/core-technology/bank-verification/account-check) del pas de
        verificació bancària, executada des del teu backend.


        **El que envies.** El `country` del compte (ISO 3166-1 alfa-3), el
        compte (`account`) tal com s'escriu en aquest país, i el nom del titular
        (`holder`): `full_name` per a una persona física o `business_name` per a
        una empresa. Un nom d'empresa comprova un compte d'empresa.


        **El que reps.** `result` és `match`, `close_match`, `no_match` o
        `cannot_verify`. Si és `close_match`, `holder_name` és el nom sota el
        qual el banc té registrat el compte, quan el banc l'ha retornat.
        `account` es retorna emmascarat mostrant només els darrers 4 caràcters.


        **Facturació.** Cada comprovació que el banc respon es factura un cop al
        preu de comprovació de compte del país corresponent, sigui quin sigui el
        resultat: un `no_match`, un compte inexistent i un `cannot_verify` també
        es facturen. Una sol·licitud que rep un error com a resposta no es
        factura mai.


        **Cada sol·licitud és una comprovació nova.** No hi ha clau
        d'idempotència ni cap endpoint per consultar una comprovació anterior,
        de manera que una sol·licitud reintentada s'executa, i es factura, un
        altre cop. Emmagatzema la resposta.


        **Sandbox.** Utilitza una clau d'API de sandbox amb les dades de compte
        d'exemple. Una clau de sandbox no crida cap banc i no té cap cost. Els
        darrers 4 caràcters de l'IBAN o, si no n'hi ha, del número de compte,
        determinen la resposta: `0001` un `close_match` amb `holder_name`,
        `0002` un `close_match` sense ell, `0003` i `0006` un `no_match`, `0004`
        `cannot_verify`, `0005` un `503` i `0009` un `400`. Qualsevol altra
        terminació és un `match`.


        **Claus d'API.** Una clau d'API amb abast restringit necessita accés
        d'escriptura a sessions.
      operationId: post_v3_bank_account_check
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BankAccountCheckRequest'
            examples:
              Person, Nigeria:
                summary: >-
                  Un codi bancari i un número de compte, contrastats amb el nom
                  d'una persona
                value:
                  country: NGA
                  account:
                    bank_code: '000014'
                    account_number: '0123450001'
                  holder:
                    full_name: Maria Oliveira
                  vendor_data: payout_20481
              Company, Nigeria:
                summary: >-
                  Un codi bancari i un número de compte, contrastats amb el nom
                  d'una empresa
                value:
                  country: NGA
                  account:
                    bank_code: '000014'
                    account_number: '0123456789'
                  holder:
                    business_name: Northwind Trading Ltd
      responses:
        '200':
          description: >-
            El banc ha respost. La comprovació es factura, sigui quin sigui el
            resultat.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckResponse'
              examples:
                Close match:
                  summary: El banc manté el compte sota un nom similar
                  value:
                    request_id: c2f4a9e0-7b1d-4c3a-9e55-1d0a6b8f2a47
                    result: close_match
                    holder_name: MARIA R OLIVEIRA
                    account: '****0001'
                    vendor_data: payout_20481
                    created_at: '2026-10-21T14:32:08Z'
                Match:
                  summary: El banc manté el compte sota el nom enviat
                  value:
                    request_id: 5b0e2d7c-41a8-4f6e-9c3b-8e7d1a2f6c90
                    result: match
                    holder_name: null
                    account: '****6789'
                    vendor_data: null
                    created_at: '2026-10-21T14:35:41Z'
        '400':
          description: >-
            Rebutjada tal com s'ha enviat, i no facturada. `field` indica el
            camp del cos que cal corregir i `reason` n'explica el motiu, amb els
            mateixos motius que mostra el formulari de compte allotjat. Només
            s'informa del primer camp rebutjat.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Missing field:
                  summary: La comprovació del país requereix un codi bancari
                  value:
                    detail: The bank code is not valid (required).
                    code: invalid_account_input
                    field: account.bank_code
                    reason: required
                Invalid IBAN:
                  summary: L'IBAN té una longitud incorrecta per al seu país
                  value:
                    detail: The iban is not valid (length).
                    code: invalid_account_input
                    field: account.iban
                    reason: length
                Refused by the bank:
                  summary: El banc ha rebutjat el compte tal com s'ha enviat
                  value:
                    detail: The account was refused as typed (rejected).
                    code: invalid_account_input
                    field: account.account_number
                    reason: rejected
                No name:
                  summary: '`holder` no té ni `full_name` ni `business_name`'
                  value:
                    detail: >-
                      Send full_name for a person or business_name for a
                      company.
                    code: invalid_account_input
                    field: holder
                    reason: required
                Consent required:
                  summary: >-
                    La comprovació del compte del país requereix el consentiment
                    del titular del compte
                  value:
                    detail: >-
                      Account checks in this country need the account holder's
                      explicit consent. Ask for it, then send `consent=true`.
                    code: invalid_account_input
                    field: consent
                    reason: required
        '401':
          description: La clau d'API amb abast ha caducat.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Expired key:
                  summary: La data de caducitat de la clau ha passat
                  value:
                    detail: This API key has expired.
        '402':
          description: >-
            La comprovació no es pot pagar, de manera que no s'ha executat.
            Recarrega el teu saldo i torna-la a enviar.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Out of credit:
                  summary: El teu saldo no pot cobrir una comprovació
                  value:
                    detail: >-
                      You don't have enough credits to perform this request.
                      Please top up at https://business.didit.me
                    code: insufficient_credits
                Not in your contract:
                  summary: El teu contracte no té cap preu per a l'API Account check
                  value:
                    detail: >-
                      Your contract does not price the Account check API.
                      Contact your account manager.
                    code: contract_rate_missing
        '403':
          description: >-
            Falta la capçalera `x-api-key` o el token de portador, o no són
            vàlids; la sol·licitud prové d'una adreça fora de la llista d'IP de
            la clau, o una clau amb àmbit no té accés d'escriptura a les
            sessions.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Missing or invalid credentials:
                  summary: Cap clau d'API o token vàlids
                  value:
                    detail: You do not have permission to perform this action.
                No sessions write:
                  summary: >-
                    Una clau amb abast restringit sense accés d'escriptura a les
                    sessions
                  value:
                    detail: This API key has no write access to sessions.
        '404':
          description: >-
            Cap verificació de compte dona servei a aquest compte encara, de
            manera que no s'ha comprovat ni facturat res. `country_not_covered`:
            cap dona servei al seu país, o al seu tipus de compte (persona o
            empresa) allà. `bank_not_covered`: cap dona servei al seu banc.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Country not covered:
                  summary: Cap verificació de compte dona servei al país
                  value:
                    detail: No account check serves this country yet.
                    code: country_not_covered
                Bank not covered:
                  summary: Cap verificació de compte dona servei al banc del compte
                  value:
                    detail: No account check serves this account's bank yet.
                    code: bank_not_covered
        '429':
          $ref: '#/components/responses/RateLimitedWrite'
        '503':
          description: >-
            El banc no ha pogut respondre. No s'ha comprovat ni facturat res;
            torna a enviar la comprovació més tard.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BankAccountCheckError'
              examples:
                Unavailable:
                  summary: El banc no ha respost
                  value:
                    detail: >-
                      The account check is temporarily unavailable and this
                      request was not charged. Please try again.
                    code: account_check_unavailable
      security:
        - ApiKeyAuth: []
        - BearerAuth: []
      x-codeSamples:
        - lang: curl
          label: curl
          source: |-
            curl -X POST https://verification.didit.me/v3/bank/account-check/ \
              -H 'x-api-key: YOUR_API_KEY' \
              -H 'Content-Type: application/json' \
              -d '{
                "country": "NGA",
                "account": {"bank_code": "000014", "account_number": "0123450001"},
                "holder": {"full_name": "Maria Oliveira"},
                "vendor_data": "payout_20481"
              }'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.bank.account_check(
                country="NGA",
                account={
                    "account_number": "0123450001",
                    "bank_code": "000014",
                },
                holder={
                    "full_name": "Maria Oliveira",
                },
                vendor_data="payout_20481",
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

            // Reads DIDIT_API_KEY.
            const didit = new Didit();

            const result = await didit.bank.accountCheck({
              country: "NGA",
              account: {
                account_number: "0123450001",
                bank_code: "000014",
              },
              holder: {
                full_name: "Maria Oliveira",
              },
              vendor_data: "payout_20481",
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Bank.AccountCheck(ctx, didit.BankAccountCheckRequest{\n\tCountry: \"NGA\",\n\tAccount: didit.BankAccountCheckRequestAccount{\n\t\tAccountNumber: didit.String(\"0123450001\"),\n\t\tBankCode:      didit.String(\"000014\"),\n\t},\n\tHolder: didit.BankAccountCheckHolder{\n\t\tFullName: didit.String(\"Maria Oliveira\"),\n\t},\n\tVendorData: didit.String(\"payout_20481\"),\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import me.didit.Didit;

            import me.didit.types.BankAccountCheckHolder;

            import me.didit.types.BankAccountCheckPersonHolder;

            import me.didit.types.BankAccountCheckRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.bank().accountCheck(BankAccountCheckRequest.builder()
                    .country("NGA")
                    .account(BankAccountCheckRequest.Account.builder()
                            .accountNumber("0123450001")
                            .bankCode("000014")
                            .build())
                    .holder(BankAccountCheckHolder.ofBankAccountCheckPersonHolder(BankAccountCheckPersonHolder.builder()
                            .fullName("Maria Oliveira")
                            .build()))
                    .vendorData("payout_20481")
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;

            // Reads DIDIT_API_KEY.
            $didit = new DiditClient();

            $result = $didit->bank->accountCheck([
                'country' => 'NGA',
                'account' => [
                    'account_number' => '0123450001',
                    'bank_code' => '000014',
                ],
                'holder' => [
                    'full_name' => 'Maria Oliveira',
                ],
                'vendor_data' => 'payout_20481',
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

            # Reads DIDIT_API_KEY.
            didit = Didit::Client.new

            result = didit.bank.account_check(
              country: "NGA",
              account: {
                account_number: "0123450001",
                bank_code: "000014",
              },
              holder: {
                full_name: "Maria Oliveira",
              },
              vendor_data: "payout_20481"
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var result = await client.Bank.AccountCheckAsync(new
            BankAccountCheckRequest

            {
                Country = "NGA",
                Account = new()
                {
                    AccountNumber = "0123450001",
                    BankCode = "000014",
                },
                Holder = new()
                {
                    FullName = "Maria Oliveira",
                },
                VendorData = "payout_20481",
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    BankAccountCheckRequest:
      type: object
      required:
        - country
        - account
        - holder
      properties:
        country:
          type: string
          minLength: 3
          maxLength: 3
          description: >-
            El país del compte, com a codi ISO 3166-1 alpha-3, per exemple
            `NGA`. S'admeten minúscules.
          example: NGA
        account:
          type: object
          description: >-
            El compte tal com s'escriu al seu país: un `iban`, o un
            `account_number` amb el codi de banc o de sucursal que el país
            necessita (`sort_code`, `routing_number`, `transit_institution`,
            `bsb`, `ifsc`, `bank_code` o `bic`). Mèxic utilitza una `clabe` i
            l'Argentina un `cbu_cvu`, que ja identifiquen el banc. Un compte
            d'empresa afegeix un `registration_id` quan el país ho demana. Els
            espais, guions i punts s'ignoren. Les claus que la comprovació del
            país no utilitza s'ignoren; una clau que necessita i no rep és un
            error `400` que n'indica el nom.
          properties:
            iban:
              type: string
              maxLength: 64
              description: >-
                L'IBAN, en un país que utilitza IBAN. Ha de pertànyer a
                `country`.
            account_number:
              type: string
              maxLength: 64
              description: >-
                El número de compte, en un país que escriu el compte amb un codi
                de banc o de sucursal separat.
            sort_code:
              type: string
              maxLength: 64
              description: 'Regne Unit: el codi de classificació bancària de 6 dígits.'
            routing_number:
              type: string
              maxLength: 64
              description: 'Estats Units: el número d''encaminament ABA de 9 dígits.'
            transit_institution:
              type: string
              maxLength: 64
              description: 'Canadà: el número de trànsit i d''institució de 8 dígits.'
            bsb:
              type: string
              maxLength: 64
              description: 'Austràlia: el BSB de 6 dígits.'
            ifsc:
              type: string
              maxLength: 64
              description: 'Índia: el codi IFSC d''11 caràcters.'
            bank_code:
              type: string
              maxLength: 64
              description: >-
                El codi del banc, quan el país en necessita un, per exemple a
                Nigèria.
            bic:
              type: string
              maxLength: 64
              description: El BIC del banc, quan la comprovació del país en demana un.
            clabe:
              type: string
              maxLength: 64
              description: 'Mèxic: la CLABE de 18 dígits. Ja identifica el banc.'
            cbu_cvu:
              type: string
              maxLength: 64
              description: 'Argentina: el CBU o CVU de 22 dígits. Ja indica el banc.'
            registration_id:
              type: string
              maxLength: 64
              description: >-
                El número de registre d'un compte d'empresa, quan el país en
                sol·licita un.
          additionalProperties:
            type: string
            maxLength: 64
          example:
            bank_code: '000014'
            account_number: '0123450001'
        holder:
          $ref: '#/components/schemas/BankAccountCheckHolder'
        vendor_data:
          type: string
          nullable: true
          description: >-
            La teva pròpia referència per a aquesta comprovació, retornada sense
            canvis.
          example: payout_20481
        consent:
          type: boolean
          default: false
          description: >-
            Estableix-ho a `true` quan el titular del compte hagi donat el
            consentiment explícit per a aquesta comprovació. Requerit als països
            on la comprovació de comptes necessita aquest consentiment: sense
            ell, la comprovació es rebutja amb un `400` en què `field` és
            `consent` i `reason` és `required`, i no es factura res. A la resta
            de països és opcional, i Didit el registra amb el càrrec de la
            comprovació quan l'envies.
          example: true
    BankAccountCheckResponse:
      type: object
      required:
        - request_id
        - result
        - holder_name
        - account
        - vendor_data
        - created_at
      properties:
        request_id:
          type: string
          format: uuid
          description: L'ID d'aquesta comprovació.
        result:
          type: string
          enum:
            - match
            - close_match
            - no_match
            - cannot_verify
          description: >-
            `match`: el banc té el compte sota el nom que has enviat.
            `close_match`: sota un nom proper, per exemple amb un segon nom
            absent o una errada tipogràfica. `no_match`: sota un altre nom, o
            aquest compte no existeix. `cannot_verify`: el banc ha respost sense
            comparar el nom, per exemple en un compte bloquejat o tancat.
        holder_name:
          type: string
          nullable: true
          description: >-
            Només en cas de `close_match`, i només quan el banc l'hagi retornat:
            el nom al compte, tal com el té el banc. Altrament, `null`.
        account:
          type: string
          description: El compte, emmascarat amb els seus últims 4 caràcters.
        vendor_data:
          type: string
          nullable: true
          description: La teva pròpia referència, tal com la vas enviar.
        created_at:
          type: string
          format: date-time
          description: Quan es va executar la comprovació, en UTC.
    BankAccountCheckError:
      type: object
      required:
        - detail
      properties:
        detail:
          type: string
          description: Què ha fallat, en anglès.
        code:
          type: string
          description: Un codi estable per bifurcar. Absent a `401` i `403`.
        field:
          type: string
          description: >-
            Només `400`: el camp del cos a corregir, com a ruta amb punts, per
            exemple `account.sort_code`.
        reason:
          type: string
          enum:
            - required
            - length
            - format
            - checksum
            - country_mismatch
            - rejected
          description: >-
            Només `400`: motiu pel qual s'ha rebutjat el camp. `required`,
            `length`, `format`, `checksum` i `country_mismatch` (un IBAN d'un
            altre país) són comprovacions pròpies de Didit; `rejected` significa
            que el banc ha rebutjat el compte tal com s'ha enviat.
    BankAccountCheckHolder:
      description: >-
        El nom amb què es comprova el compte. Envia exactament un dels camps
        `full_name` i `business_name`.
      oneOf:
        - $ref: '#/components/schemas/BankAccountCheckPersonHolder'
        - $ref: '#/components/schemas/BankAccountCheckBusinessHolder'
    BankAccountCheckPersonHolder:
      type: object
      description: La persona que hauria de ser titular del compte.
      required:
        - full_name
      properties:
        full_name:
          type: string
          maxLength: 255
          description: El nom complet de la persona que hauria de ser titular del compte.
          example: Maria Oliveira
    BankAccountCheckBusinessHolder:
      type: object
      description: >-
        L'empresa que hauria de ser titular del compte. Comprova un compte
        d'empresa.
      required:
        - business_name
      properties:
        business_name:
          type: string
          maxLength: 255
          description: >-
            El nom de l'empresa que hauria de ser titular del compte. Comprova
            un compte d'empresa.
  responses:
    RateLimitedWrite:
      description: >-
        S'ha superat el límit compartit d'escriptura de 300 sol·licituds per
        minut per clau d'API. Respecta `Retry-After` abans de reintentar.
      content:
        application/json:
          schema:
            type: object
            required:
              - detail
            properties:
              detail:
                type: string
          example:
            detail: >-
              Write request rate limit exceeded. You can make up to 300 requests
              per minute.
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clau d'API de la teva aplicació, des de Developers -> API keys a la
        Business Console. La clau primària té accés complet. Una clau amb nom
        pot tenir l'abast limitat: cap, lectura o escriptura per recurs,
        limitada a determinats fluxos de treball o a sessions aprovades, a una
        llista d'adreces IP i a una data de caducitat. 401 significa que la clau
        és incorrecta, revocada o caducada; 403 significa que no s'ha enviat cap
        clau, que la clau no té accés a aquest recurs o acció, o que la
        sol·licitud prové d'una adreça fora de la seva llista d'IP; 404 en una
        ruta de sessió significa que la sessió està fora dels fluxos de treball
        o estats de la clau. Una clau sense accés a fitxers multimèdia rep els
        URL d'imatge, vídeo i PDF com a null, i una clau sense permís
        d'escriptura de sessions rep els enllaços de sessió i els tokens com a
        null. Consulta https://docs.didit.me/console/api-keys.
    BearerAuth:
      type: http
      scheme: bearer
      description: El token d'accés de credencials de client de l'aplicació.

````

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