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

# Gets Payment Account Listing

> 
Gets the consumer Payment Account Listing.

A Payment Account is an object describing where the cashback money should be transfered.

It has:

- A payout account: Where the cashback money should be transfered out of the Payment
Service Provider.

- A target account: Where the cashback money should end up. This is the actual
account of the consumer.

If external ventilation, the payout account is the Program Manager pivot account,
and the target account is the account of the consumer.

In case of internal ventilation, payout account = target account = account of
the consumer.




## OpenAPI

````yaml /program/api/openapi/legacy/1.1.8/connector.json get /connectors/consumers/{consumer_id}/accounts/payment
openapi: 3.0.2
info:
  description: >
    ## Welcome to PayLead API Documentation !

    With this documentation, we will help you go through the phases of

    basic implementation, and help you understand the basic steps to let you
    reach your objectives through our API.

    ## Versioning

    Our API supports versioning, so be sure to set the right version in the
    header, using the Client-Api-Version field :


    ex : X-Api-Version = 1.0.0

    ## Response code

    Our API returns standard HTTP response codes to indicate success or failure
    of the API requests. For

    errors, we also return a customized error message inside the JSON response.
    You can see the returned

    HTTP status codes below.


    |Code|Title|Description

    |------|------|------|

    |200|OK|Request successful

    |201|Created|Resource successfully created

    |204|No Content|Request successful with no content returned

    |400|Bad Request|Request was unacceptable

    |401|Unauthorised|API key provided is invalid

    |402|Request Failed|Valid parameters but the request failed

    |403|Forbidden|Access is forbidden.

    |404|Not Found|Resource does not exist

    |409|Conflict|The request could not be completed due to a conflict with the
    current state of the target resource

    |429|Too Many Requests|The user has sent too many requests in a given amount
    of time ("rate limiting").

    |500, 502, 503, 504|Server Errors|Something went wrong with the PayLead API


    ## Error handling

    In case of error our API returns errors based on JSON API principles,
    especially for 4xx errors.

    An error response contains an unique id which can be used for investigation.

    In addition, you will find a message explaining the error, a readable code
    and a meta object containing more details.


    You can see an example below.


    >> ~~~~

    >> {

    >>     'errors': {

    >>             'target_account': [

    >>                 {

    >>                 'code': 'FORMAT_ERROR',

    >>                 'message': 'Invalid IBAN; it should be 4-34 characters,
    only upper-case letters and digits.',

    >>                 'meta': {

    >>                     'value': 'SOME-INVALID-IBAN'

    >>                 }

    >>             }

    >>         ]

    >>     },

    >>     'id': '784db0c2-0e87-40d4-aa62-3e801135ccf7'

    >> }

    >> ~~~~

    ## Language — Content Negotiation

    If your program has been configured to support multiple languages, the API
    will respect the `Accept-Language` header as defined in
    [RFC7231](https://tools.ietf.org/html/rfc7231#section-5.3.5).


    For each incoming request, the best language will be selected by matching
    the list of languages accepted by the client with the list of languages
    supported by the program.


    For example, with a header of `Accept-Language: fr-FR,en-GB;q=0.8,en;q=0.3`:

      * If supported languages are `fr-FR, en-GB`, the best match is `fr-FR`;
      * If supported languages are `en-GB, fr-FR`, the best match is `fr-FR`;
      * If supported languages are `fr-BE, nl-BE`, the best match is `fr-BE`;
      * If supported languages are `it-IT, en-US`, the best match is `en-US`;
      * If supported languages are `de-CH, it-CH`, the best match is `de-CH`.


    The selected language will be exposed through the `Content-Language` header.


    *Note:* If some fields haven't been translated yet, they will be returned in
    the program's primary language.
  title: PayLead API
  version: 1.1.8
servers:
  - url: https://api.sandbox.paylead.tech
security:
  - ApiKeyAuth: []
paths:
  /connectors/consumers/{consumer_id}/accounts/payment:
    get:
      tags:
        - Payment Account
      summary: Gets Payment Account Listing
      description: >

        Gets the consumer Payment Account Listing.


        A Payment Account is an object describing where the cashback money
        should be transfered.


        It has:


        - A payout account: Where the cashback money should be transfered out of
        the Payment

        Service Provider.


        - A target account: Where the cashback money should end up. This is the
        actual

        account of the consumer.


        If external ventilation, the payout account is the Program Manager pivot
        account,

        and the target account is the account of the consumer.


        In case of internal ventilation, payout account = target account =
        account of

        the consumer.
      operationId: get.PaymentAccountListResource.impersonate
      parameters:
        - description: The id you used to create the given consumer
          in: path
          name: consumer_id
          required: true
          schema:
            type: string
        - description: the page number
          in: query
          name: page
          required: false
          schema:
            minimum: 1
            type: integer
        - description: the number of elements per page
          in: query
          name: per_page
          required: false
          schema:
            maximum: 100
            minimum: 1
            type: integer
      responses:
        '200':
          content:
            application/json:
              schema:
                properties:
                  items:
                    items:
                      $ref: '#/components/schemas/PaymentAccount'
                    type: array
                  meta:
                    properties:
                      page:
                        type: integer
                      per_page:
                        type: integer
                      total:
                        type: integer
          description: OK
          links:
            get.PaymentAccountResource:
              operationId: get.PaymentAccountResource.impersonate
              parameters:
                consumer_id: $request.path.consumer_id
                mpa_id: $response.body#/items/0/id
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ValidationError'
          description: Bad request
        '401':
          description: Unauthorized
        '403':
          description: Not allowed to access the resource
        '404':
          description: Not found
        '405':
          description: Method not allowed
        '422':
          description: Unprocessable Entity
components:
  schemas:
    PaymentAccount:
      properties:
        id:
          description: Unique ID of the object.
          example: e2c32b4b-de61-459b-accf-a75f76247946
          format: uuid
          readOnly: true
          type: string
        owner_info:
          anyOf:
            - $ref: '#/components/schemas/OwnerInfo'
            - nullable: true
              type: object
        payout_account:
          description: Consumer payout account object
          example: FR7630006000011234567890189
          nullable: true
          readOnly: true
          type: string
        status:
          description: 'TRUE: Payment account is valid, FALSE: Payment account is not valid'
          example: true
          readOnly: true
          type: boolean
        target_account:
          description: Consumer payment account object
          example: FR7630006000011234567890189
          type: string
      required:
        - target_account
      type: object
    ValidationError:
      properties:
        errors:
          additionalProperties:
            items:
              $ref: '#/components/schemas/Error'
            type: array
          description: Errors during the validation process.
          type: object
        id:
          description: Unique ID of the object.
          example: e2c32b4b-de61-459b-accf-a75f76247946
          format: uuid
          type: string
      type: object
    OwnerInfo:
      properties:
        address:
          anyOf:
            - $ref: '#/components/schemas/OwnerAddress'
            - nullable: true
              type: object
        name:
          default: null
          description: Name of the object
          nullable: true
          type: string
      type: object
    Error:
      properties:
        code:
          description: Error code.
        message:
          description: Error message.
          type: string
        meta:
          description: Meta information of the error.
      required:
        - message
      type: object
    OwnerAddress:
      properties:
        city:
          description: City of the store
          example: Paris
          type: string
        country:
          description: Country of the store
          example: France
          type: string
        region:
          default: null
          description: Region of the address.
          nullable: true
          type: string
        street:
          description: Street of the address.
          type: string
        zip_code:
          description: Zip code of the store
          example: 84120
          type: string
      required:
        - city
        - country
        - street
        - zip_code
      type: object
  securitySchemes:
    ApiKeyAuth:
      bearerFormat: JWT
      scheme: bearer
      type: http

````