Skip to content

Verification

VerificationClient

Bases: BaseAPIClient

Provides a wrapper for paystack Verification API

The Verification API allows you to perform KYC processes. https://paystack.com/docs/api/verification/

Note

This feature is only available to businesses in Nigeria.

Source code in src/pypaystack2/sub_clients/sync_clients/verification.py 
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
class VerificationClient(BaseAPIClient):
    """Provides a wrapper for paystack Verification API

    The Verification API allows you to perform KYC processes.
    https://paystack.com/docs/api/verification/

    Note:
        This feature is only available to businesses in Nigeria.
    """

    def resolve_account_number(
        self,
        account_number: str,
        bank_code: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[BankAccountInfo] | Response[PaystackDataModel]:
        """Confirm an account belongs to the right customer

        Note:
            Feature Availability
                This feature is only available to businesses in Nigeria.

        Args:
            account_number: Account Number
            bank_code: You can get the list of bank codes by calling
                `PaystackClient.miscellaneous.get_banks` method.
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """
        url = self._full_url(
            f"/bank/resolve?account_number={account_number}&bank_code={bank_code}"
        )
        return self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or BankAccountInfo,
        )

    def validate_account(
        self,
        account_name: str,
        account_number: str,
        account_type: AccountType,
        bank_code: str,
        country_code: Country,
        document_type: Document,
        document_number: str | None = None,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[AccountVerificationInfo] | Response[PaystackDataModel]:
        """Confirm the authenticity of a customer's account number before sending money

        Args:
            account_name: Customer's first and last name registered with their bank
            account_number: Customer's account number
            account_type: bank_code: The bank code of the customer’s bank. You can fetch the bank codes by
                using `PaystackClient.miscellaneous.get_banks` method.
            bank_code: The bank code of the customer’s bank
            country_code: Any value from the ``Country`` enum
            document_type: Customer’s mode of identity. any value from the
                `Document` enum.
            document_number: Customer’s mode of identity number
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        payload = {
            "account_name": account_name,
            "account_number": account_number,
            "account_type": account_type,
            "bank_code": bank_code,
            "country_code": country_code,
            "document_type": document_type,
            "document_number": document_number,
        }
        url = self._full_url("/bank/validate")

        return self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or AccountVerificationInfo,
        )

    def resolve_card_bin(
        self,
        bin_: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[CardBin] | Response[PaystackDataModel]:
        """Get more information about a customer's card

        Args:
            bin_: First 6 characters of card
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.


        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/decision/bin/{bin_}")
        return self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or CardBin,
        )

resolve_account_number(account_number, bank_code, alternate_model_class=None)

Confirm an account belongs to the right customer

Note

Feature Availability This feature is only available to businesses in Nigeria.

Parameters:

Name Type Description Default
account_number str

Account Number

 required
bank_code str

You can get the list of bank codes by calling PaystackClient.miscellaneous.get_banks method.

 required
alternate_model_class type[PaystackDataModel] | None

A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.

 None

Returns:

Type Description
Response[BankAccountInfo] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/sync_clients/verification.py 
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
def resolve_account_number(
    self,
    account_number: str,
    bank_code: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[BankAccountInfo] | Response[PaystackDataModel]:
    """Confirm an account belongs to the right customer

    Note:
        Feature Availability
            This feature is only available to businesses in Nigeria.

    Args:
        account_number: Account Number
        bank_code: You can get the list of bank codes by calling
            `PaystackClient.miscellaneous.get_banks` method.
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """
    url = self._full_url(
        f"/bank/resolve?account_number={account_number}&bank_code={bank_code}"
    )
    return self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or BankAccountInfo,
    )

resolve_card_bin(bin_, alternate_model_class=None)

Get more information about a customer's card

Parameters:

Name Type Description Default
bin_ str

First 6 characters of card

 required
alternate_model_class type[PaystackDataModel] | None

A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.

 None

Returns:

Type Description
Response[CardBin] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/sync_clients/verification.py 
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
def resolve_card_bin(
    self,
    bin_: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[CardBin] | Response[PaystackDataModel]:
    """Get more information about a customer's card

    Args:
        bin_: First 6 characters of card
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.


    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/decision/bin/{bin_}")
    return self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or CardBin,
    )

validate_account(account_name, account_number, account_type, bank_code, country_code, document_type, document_number=None, alternate_model_class=None)

Confirm the authenticity of a customer's account number before sending money

Parameters:

Name Type Description Default
account_name str

Customer's first and last name registered with their bank

 required
account_number str

Customer's account number

 required
account_type AccountType

bank_code: The bank code of the customer’s bank. You can fetch the bank codes by using PaystackClient.miscellaneous.get_banks method.

 required
bank_code str

The bank code of the customer’s bank

 required
country_code Country

Any value from the Country enum

 required
document_type Document

Customer’s mode of identity. any value from the Document enum.

 required
document_number str | None

Customer’s mode of identity number

 None
alternate_model_class type[PaystackDataModel] | None

A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.

 None

Returns:

Type Description
Response[AccountVerificationInfo] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/sync_clients/verification.py 
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
def validate_account(
    self,
    account_name: str,
    account_number: str,
    account_type: AccountType,
    bank_code: str,
    country_code: Country,
    document_type: Document,
    document_number: str | None = None,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[AccountVerificationInfo] | Response[PaystackDataModel]:
    """Confirm the authenticity of a customer's account number before sending money

    Args:
        account_name: Customer's first and last name registered with their bank
        account_number: Customer's account number
        account_type: bank_code: The bank code of the customer’s bank. You can fetch the bank codes by
            using `PaystackClient.miscellaneous.get_banks` method.
        bank_code: The bank code of the customer’s bank
        country_code: Any value from the ``Country`` enum
        document_type: Customer’s mode of identity. any value from the
            `Document` enum.
        document_number: Customer’s mode of identity number
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    payload = {
        "account_name": account_name,
        "account_number": account_number,
        "account_type": account_type,
        "bank_code": bank_code,
        "country_code": country_code,
        "document_type": document_type,
        "document_number": document_number,
    }
    url = self._full_url("/bank/validate")

    return self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or AccountVerificationInfo,
    )

AsyncVerificationClient

Bases: BaseAsyncAPIClient

Provides a wrapper for paystack Verification API

The Verification API allows you to perform KYC processes. https://paystack.com/docs/api/verification/

Note

This feature is only available to businesses in Nigeria.

Source code in src/pypaystack2/sub_clients/async_clients/verification.py 
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
class AsyncVerificationClient(BaseAsyncAPIClient):
    """Provides a wrapper for paystack Verification API

    The Verification API allows you to perform KYC processes.
    https://paystack.com/docs/api/verification/

    Note:
        This feature is only available to businesses in Nigeria.
    """

    async def resolve_account_number(
        self,
        account_number: str,
        bank_code: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[BankAccountInfo] | Response[PaystackDataModel]:
        """Confirm an account belongs to the right customer

        Note:
            Feature Availability
                This feature is only available to businesses in Nigeria.

        Args:
            account_number: Account Number
            bank_code: You can get the list of bank codes by calling
                `PaystackClient.miscellaneous.get_banks` method.
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """
        url = self._full_url(
            f"/bank/resolve?account_number={account_number}&bank_code={bank_code}"
        )
        return await self._handle_request(
            HTTPMethod.GET,
            url,  # type: ignore
            response_data_model_class=alternate_model_class or BankAccountInfo,
        )

    async def validate_account(
        self,
        account_name: str,
        account_number: str,
        account_type: AccountType,
        bank_code: str,
        country_code: Country,
        document_type: Document,
        document_number: str | None = None,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[AccountVerificationInfo] | Response[PaystackDataModel]:
        """Confirm the authenticity of a customer's account number before sending money

        Args:
            account_name: Customer's first and last name registered with their bank
            account_number: Customer's account number
            account_type: bank_code: The bank code of the customer’s bank. You can fetch the bank codes by
                using `PaystackClient.miscellaneous.get_banks` method.
            bank_code: The bank code of the customer’s bank
            country_code: Any value from the ``Country`` enum
            document_type: Customer’s mode of identity. any value from the
                ``Document`` enum.
            document_number: Customer’s mode of identity number
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        payload = {
            "account_name": account_name,
            "account_number": account_number,
            "account_type": account_type,
            "bank_code": bank_code,
            "country_code": country_code,
            "document_type": document_type,
            "document_number": document_number,
        }
        url = self._full_url("/bank/validate")

        return await self._handle_request(
            HTTPMethod.POST,
            url,
            payload,  # type: ignore
            response_data_model_class=alternate_model_class or AccountVerificationInfo,
        )

    async def resolve_card_bin(
        self,
        bin_: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[CardBin] | Response[PaystackDataModel]:
        """Get more information about a customer's card

        Args:
            bin_: First 6 characters of card
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.


        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/decision/bin/{bin_}")
        return await self._handle_request(
            HTTPMethod.GET,
            url,  # type: ignore
            response_data_model_class=alternate_model_class or CardBin,
        )

resolve_account_number(account_number, bank_code, alternate_model_class=None) async

Confirm an account belongs to the right customer

Note

Feature Availability This feature is only available to businesses in Nigeria.

Parameters:

Name Type Description Default
account_number str

Account Number

 required
bank_code str

You can get the list of bank codes by calling PaystackClient.miscellaneous.get_banks method.

 required
alternate_model_class type[PaystackDataModel] | None

A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.

 None

Returns:

Type Description
Response[BankAccountInfo] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/async_clients/verification.py 
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
async def resolve_account_number(
    self,
    account_number: str,
    bank_code: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[BankAccountInfo] | Response[PaystackDataModel]:
    """Confirm an account belongs to the right customer

    Note:
        Feature Availability
            This feature is only available to businesses in Nigeria.

    Args:
        account_number: Account Number
        bank_code: You can get the list of bank codes by calling
            `PaystackClient.miscellaneous.get_banks` method.
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """
    url = self._full_url(
        f"/bank/resolve?account_number={account_number}&bank_code={bank_code}"
    )
    return await self._handle_request(
        HTTPMethod.GET,
        url,  # type: ignore
        response_data_model_class=alternate_model_class or BankAccountInfo,
    )

resolve_card_bin(bin_, alternate_model_class=None) async

Get more information about a customer's card

Parameters:

Name Type Description Default
bin_ str

First 6 characters of card

 required
alternate_model_class type[PaystackDataModel] | None

A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.

 None

Returns:

Type Description
Response[CardBin] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/async_clients/verification.py 
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
async def resolve_card_bin(
    self,
    bin_: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[CardBin] | Response[PaystackDataModel]:
    """Get more information about a customer's card

    Args:
        bin_: First 6 characters of card
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.


    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/decision/bin/{bin_}")
    return await self._handle_request(
        HTTPMethod.GET,
        url,  # type: ignore
        response_data_model_class=alternate_model_class or CardBin,
    )

validate_account(account_name, account_number, account_type, bank_code, country_code, document_type, document_number=None, alternate_model_class=None) async

Confirm the authenticity of a customer's account number before sending money

Parameters:

Name Type Description Default
account_name str

Customer's first and last name registered with their bank

 required
account_number str

Customer's account number

 required
account_type AccountType

bank_code: The bank code of the customer’s bank. You can fetch the bank codes by using PaystackClient.miscellaneous.get_banks method.

 required
bank_code str

The bank code of the customer’s bank

 required
country_code Country

Any value from the Country enum

 required
document_type Document

Customer’s mode of identity. any value from the Document enum.

 required
document_number str | None

Customer’s mode of identity number

 None
alternate_model_class type[PaystackDataModel] | None

A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.

 None

Returns:

Type Description
Response[AccountVerificationInfo] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/async_clients/verification.py 
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
async def validate_account(
    self,
    account_name: str,
    account_number: str,
    account_type: AccountType,
    bank_code: str,
    country_code: Country,
    document_type: Document,
    document_number: str | None = None,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[AccountVerificationInfo] | Response[PaystackDataModel]:
    """Confirm the authenticity of a customer's account number before sending money

    Args:
        account_name: Customer's first and last name registered with their bank
        account_number: Customer's account number
        account_type: bank_code: The bank code of the customer’s bank. You can fetch the bank codes by
            using `PaystackClient.miscellaneous.get_banks` method.
        bank_code: The bank code of the customer’s bank
        country_code: Any value from the ``Country`` enum
        document_type: Customer’s mode of identity. any value from the
            ``Document`` enum.
        document_number: Customer’s mode of identity number
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    payload = {
        "account_name": account_name,
        "account_number": account_number,
        "account_type": account_type,
        "bank_code": bank_code,
        "country_code": country_code,
        "document_type": document_type,
        "document_number": document_number,
    }
    url = self._full_url("/bank/validate")

    return await self._handle_request(
        HTTPMethod.POST,
        url,
        payload,  # type: ignore
        response_data_model_class=alternate_model_class or AccountVerificationInfo,
    )