Skip to content

Charge

ChargeClient

Bases: BaseAPIClient

Provides a wrapper for paystack Charge API

The Charge API allows you to configure a payment channel of your choice when initiating a payment. https://paystack.com/docs/api/charge/

Source code in src/pypaystack2/sub_clients/sync_clients/charge.py 
 10
 11
 12
 13
 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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
class ChargeClient(BaseAPIClient):
    """Provides a wrapper for paystack Charge API

    The Charge API allows you to configure a payment channel of your choice when initiating a payment.
    https://paystack.com/docs/api/charge/

    """

    def charge(
        self,
        email: str,
        amount: int,
        bank: dict[str, Any] | None = None,
        bank_transfer: dict[str, Any] | None = None,
        auth_code: str | None = None,
        pin: str | None = None,
        metadata: dict[str, Any] | None = None,
        reference: str | None = None,
        ussd: dict[str, Any] | None = None,
        mobile_money: dict[str, Any] | None = None,
        device_id: str | None = None,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Initiate a payment by integrating the payment channel of your choice.

        Args:
            email: Customer's email address
            amount: Amount should be in kobo if currency is NGN, pesewas, if currency is GHS,
                and cents, if currency is ZAR
            bank: Bank account to charge (don't send if charging an authorization code)
            bank_transfer: Takes the settings for the Pay with Transfer (PwT) channel. Pass in the
                account_expires_at param to set the expiry time.
            auth_code: An authorization code to charge (don't send if charging a bank account)
            pin: 4-digit PIN (send with a non-reusable authorization code)
            metadata: A dictionary of data.
            reference: Unique transaction reference. Only -, .\\`, = and alphanumeric characters allowed.
            ussd: USSD type to charge (don't send if charging an authorization code, bank or card)
            mobile_money: Mobile details (don't send if charging an authorization code, bank or card)
            device_id: This is the unique identifier of the device a user uses in making payment. Only -, .\\`,
                = and alphanumeric characters allowed.
            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 = {"email": email, "amount": amount}
        optional_params = [
            ("bank", bank),
            ("bank_transfer", bank_transfer),
            ("authorization_code", auth_code),
            ("pin", pin),
            ("metadata", metadata),
            ("reference", reference),
            ("ussd", ussd),
            ("mobile_money", mobile_money),
            ("device_id", device_id),
        ]
        payload = add_to_payload(optional_params, payload)
        url = self._full_url("/charge")
        return self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    def submit_pin(
        self,
        pin: str,
        reference: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Submit PIN to continue a charge

        Args:
            pin: PIN submitted by user
            reference: Reference for transaction that requested pin
            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 = {"pin": pin, "reference": reference}
        url = self._full_url("/charge/submit_pin")
        return self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    def submit_otp(
        self,
        otp: str,
        reference: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Submit OTP to complete a charge

        Args:
            otp: OTP submitted by user
            reference: Reference for ongoing transaction
            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 = {"otp": otp, "reference": reference}
        url = self._full_url("/charge/submit_otp")
        return self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    def submit_phone(
        self,
        phone: str,
        reference: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Submit Phone when requested

        Args:
            phone: Phone submitted by user
            reference: Reference for ongoing transaction
            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 = {"phone": phone, "reference": reference}
        url = self._full_url("/charge/submit_phone")
        return self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    def submit_birthday(
        self,
        birthday: str,
        reference: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Submit Birthday when requested

        Args:
            birthday: Birthday submitted by user. ISO Format e.g. 2016-09-21
            reference: Reference for ongoing transaction
            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 = {"birthday": birthday, "reference": reference}
        url = self._full_url("/charge/submit_birthday")
        return self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    def set_address(
        self,
        address: str,
        reference: str,
        city: str,
        state: str,
        zipcode: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Submit address to continue a charge

        Args:
            address: Address submitted by user
            reference: Reference for ongoing transaction
            city: City submitted by user
            state: State submitted by user
            zipcode: sZipcode submitted by user
            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 = {
            "address": address,
            "reference": reference,
            "city": city,
            "state": state,
            "zip_code": zipcode,
        }
        url = self._full_url("/charge/submit_address")
        return self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    def check_pending_charge(
        self,
        reference: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """
        When you get "pending" as a charge status or if there was an
        exception when calling any of the /charge endpoints, wait 10
        seconds or more, then make a check to see if its status has changed.
        Don't call too early as you may get a lot more pending than you should.

        Args:
            reference: The reference to check
            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"/charge/{reference}")
        return self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or Transaction,
        )

charge(email, amount, bank=None, bank_transfer=None, auth_code=None, pin=None, metadata=None, reference=None, ussd=None, mobile_money=None, device_id=None, alternate_model_class=None)

Initiate a payment by integrating the payment channel of your choice.

Parameters:

Name Type Description Default
email str

Customer's email address

 required
amount int

Amount should be in kobo if currency is NGN, pesewas, if currency is GHS, and cents, if currency is ZAR

 required
bank dict[str, Any] | None

Bank account to charge (don't send if charging an authorization code)

 None
bank_transfer dict[str, Any] | None

Takes the settings for the Pay with Transfer (PwT) channel. Pass in the account_expires_at param to set the expiry time.

 None
auth_code str | None

An authorization code to charge (don't send if charging a bank account)

 None
pin str | None

4-digit PIN (send with a non-reusable authorization code)

 None
metadata dict[str, Any] | None

A dictionary of data.

 None
reference str | None

Unique transaction reference. Only -, .`, = and alphanumeric characters allowed.

 None
ussd dict[str, Any] | None

USSD type to charge (don't send if charging an authorization code, bank or card)

 None
mobile_money dict[str, Any] | None

Mobile details (don't send if charging an authorization code, bank or card)

 None
device_id str | None

This is the unique identifier of the device a user uses in making payment. Only -, .`, = and alphanumeric characters allowed.

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/sync_clients/charge.py 
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
def charge(
    self,
    email: str,
    amount: int,
    bank: dict[str, Any] | None = None,
    bank_transfer: dict[str, Any] | None = None,
    auth_code: str | None = None,
    pin: str | None = None,
    metadata: dict[str, Any] | None = None,
    reference: str | None = None,
    ussd: dict[str, Any] | None = None,
    mobile_money: dict[str, Any] | None = None,
    device_id: str | None = None,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Initiate a payment by integrating the payment channel of your choice.

    Args:
        email: Customer's email address
        amount: Amount should be in kobo if currency is NGN, pesewas, if currency is GHS,
            and cents, if currency is ZAR
        bank: Bank account to charge (don't send if charging an authorization code)
        bank_transfer: Takes the settings for the Pay with Transfer (PwT) channel. Pass in the
            account_expires_at param to set the expiry time.
        auth_code: An authorization code to charge (don't send if charging a bank account)
        pin: 4-digit PIN (send with a non-reusable authorization code)
        metadata: A dictionary of data.
        reference: Unique transaction reference. Only -, .\\`, = and alphanumeric characters allowed.
        ussd: USSD type to charge (don't send if charging an authorization code, bank or card)
        mobile_money: Mobile details (don't send if charging an authorization code, bank or card)
        device_id: This is the unique identifier of the device a user uses in making payment. Only -, .\\`,
            = and alphanumeric characters allowed.
        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 = {"email": email, "amount": amount}
    optional_params = [
        ("bank", bank),
        ("bank_transfer", bank_transfer),
        ("authorization_code", auth_code),
        ("pin", pin),
        ("metadata", metadata),
        ("reference", reference),
        ("ussd", ussd),
        ("mobile_money", mobile_money),
        ("device_id", device_id),
    ]
    payload = add_to_payload(optional_params, payload)
    url = self._full_url("/charge")
    return self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )

check_pending_charge(reference, alternate_model_class=None)

When you get "pending" as a charge status or if there was an exception when calling any of the /charge endpoints, wait 10 seconds or more, then make a check to see if its status has changed. Don't call too early as you may get a lot more pending than you should.

Parameters:

Name Type Description Default
reference str

The reference to check

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/sync_clients/charge.py 
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
def check_pending_charge(
    self,
    reference: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """
    When you get "pending" as a charge status or if there was an
    exception when calling any of the /charge endpoints, wait 10
    seconds or more, then make a check to see if its status has changed.
    Don't call too early as you may get a lot more pending than you should.

    Args:
        reference: The reference to check
        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"/charge/{reference}")
    return self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or Transaction,
    )

set_address(address, reference, city, state, zipcode, alternate_model_class=None)

Submit address to continue a charge

Parameters:

Name Type Description Default
address str

Address submitted by user

 required
reference str

Reference for ongoing transaction

 required
city str

City submitted by user

 required
state str

State submitted by user

 required
zipcode str

sZipcode submitted by user

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/sync_clients/charge.py 
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
def set_address(
    self,
    address: str,
    reference: str,
    city: str,
    state: str,
    zipcode: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Submit address to continue a charge

    Args:
        address: Address submitted by user
        reference: Reference for ongoing transaction
        city: City submitted by user
        state: State submitted by user
        zipcode: sZipcode submitted by user
        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 = {
        "address": address,
        "reference": reference,
        "city": city,
        "state": state,
        "zip_code": zipcode,
    }
    url = self._full_url("/charge/submit_address")
    return self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )

submit_birthday(birthday, reference, alternate_model_class=None)

Submit Birthday when requested

Parameters:

Name Type Description Default
birthday str

Birthday submitted by user. ISO Format e.g. 2016-09-21

 required
reference str

Reference for ongoing transaction

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/sync_clients/charge.py 
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
def submit_birthday(
    self,
    birthday: str,
    reference: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Submit Birthday when requested

    Args:
        birthday: Birthday submitted by user. ISO Format e.g. 2016-09-21
        reference: Reference for ongoing transaction
        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 = {"birthday": birthday, "reference": reference}
    url = self._full_url("/charge/submit_birthday")
    return self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )

submit_otp(otp, reference, alternate_model_class=None)

Submit OTP to complete a charge

Parameters:

Name Type Description Default
otp str

OTP submitted by user

 required
reference str

Reference for ongoing transaction

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/sync_clients/charge.py 
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
156
157
158
159
160
def submit_otp(
    self,
    otp: str,
    reference: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Submit OTP to complete a charge

    Args:
        otp: OTP submitted by user
        reference: Reference for ongoing transaction
        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 = {"otp": otp, "reference": reference}
    url = self._full_url("/charge/submit_otp")
    return self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )

submit_phone(phone, reference, alternate_model_class=None)

Submit Phone when requested

Parameters:

Name Type Description Default
phone str

Phone submitted by user

 required
reference str

Reference for ongoing transaction

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/sync_clients/charge.py 
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
def submit_phone(
    self,
    phone: str,
    reference: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Submit Phone when requested

    Args:
        phone: Phone submitted by user
        reference: Reference for ongoing transaction
        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 = {"phone": phone, "reference": reference}
    url = self._full_url("/charge/submit_phone")
    return self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )

submit_pin(pin, reference, alternate_model_class=None)

Submit PIN to continue a charge

Parameters:

Name Type Description Default
pin str

PIN submitted by user

 required
reference str

Reference for transaction that requested pin

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/sync_clients/charge.py 
 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
def submit_pin(
    self,
    pin: str,
    reference: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Submit PIN to continue a charge

    Args:
        pin: PIN submitted by user
        reference: Reference for transaction that requested pin
        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 = {"pin": pin, "reference": reference}
    url = self._full_url("/charge/submit_pin")
    return self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )

AsyncChargeClient

Bases: BaseAsyncAPIClient

Provides a wrapper for paystack Charge API

The Charge API allows you to configure a payment channel of your choice when initiating a payment. https://paystack.com/docs/api/charge/

Source code in src/pypaystack2/sub_clients/async_clients/charge.py 
 10
 11
 12
 13
 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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
class AsyncChargeClient(BaseAsyncAPIClient):
    """Provides a wrapper for paystack Charge API

    The Charge API allows you to configure a payment channel of your choice when initiating a payment.
    https://paystack.com/docs/api/charge/

    """

    async def charge(
        self,
        email: str,
        amount: int,
        bank: dict[str, Any] | None = None,
        bank_transfer: dict[str, Any] | None = None,
        auth_code: str | None = None,
        pin: str | None = None,
        metadata: dict[str, Any] | None = None,
        reference: str | None = None,
        ussd: dict[str, Any] | None = None,
        mobile_money: dict[str, Any] | None = None,
        device_id: str | None = None,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Initiate a payment by integrating the payment channel of your choice.

        Args:
            email: Customer's email address
            amount: Amount should be in kobo if currency is NGN, pesewas, if currency is GHS,
                and cents, if currency is ZAR
            bank: Bank account to charge (don't send if charging an authorization code)
            bank_transfer: Takes the settings for the Pay with Transfer (PwT) channel. Pass in the
                account_expires_at param to set the expiry time.
            auth_code: An authorization code to charge (don't send if charging a bank account)
            pin: 4-digit PIN (send with a non-reusable authorization code)
            metadata: A dictionary of data.
            reference: Unique transaction reference. Only -, .\\`, = and alphanumeric characters allowed.
            ussd: USSD type to charge (don't send if charging an authorization code, bank or card)
            mobile_money: Mobile details (don't send if charging an authorization code, bank or card)
            device_id: This is the unique identifier of the device a user uses in making payment. Only -, .\\`,
                = and alphanumeric characters allowed.
            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 = {"email": email, "amount": amount}
        optional_params = [
            ("bank", bank),
            ("bank_transfer", bank_transfer),
            ("authorization_code", auth_code),
            ("pin", pin),
            ("metadata", metadata),
            ("reference", reference),
            ("ussd", ussd),
            ("mobile_money", mobile_money),
            ("device_id", device_id),
        ]
        payload = add_to_payload(optional_params, payload)
        url = self._full_url("/charge")
        return await self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    async def submit_pin(
        self,
        pin: str,
        reference: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Submit PIN to continue a charge

        Args:
            pin: PIN submitted by user
            reference: Reference for transaction that requested pin
            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 = {"pin": pin, "reference": reference}
        url = self._full_url("/charge/submit_pin")
        return await self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    async def submit_otp(
        self,
        otp: str,
        reference: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Submit OTP to complete a charge

        Args:
            otp: OTP submitted by user
            reference: Reference for ongoing transaction
            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 = {"otp": otp, "reference": reference}
        url = self._full_url("/charge/submit_otp")
        return await self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    async def submit_phone(
        self,
        phone: str,
        reference: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Submit Phone when requested

        Args:
            phone: Phone submitted by user
            reference: Reference for ongoing transaction
            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 = {"phone": phone, "reference": reference}
        url = self._full_url("/charge/submit_phone")
        return await self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    async def submit_birthday(
        self,
        birthday: str,
        reference: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Submit Birthday when requested

        Args:
            birthday: Birthday submitted by user. ISO Format e.g. 2016-09-21
            reference: Reference for ongoing transaction
            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 = {"birthday": birthday, "reference": reference}
        url = self._full_url("/charge/submit_birthday")
        return await self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    async def set_address(
        self,
        address: str,
        reference: str,
        city: str,
        state: str,
        zipcode: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """Submit address to continue a charge

        Args:
            address: Address submitted by user
            reference: Reference for ongoing transaction
            city: City submitted by user
            state: State submitted by user
            zipcode: Zipcode submitted by user
            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 = {
            "address": address,
            "reference": reference,
            "city": city,
            "state": state,
            "zip_code": zipcode,
        }
        url = self._full_url("/charge/submit_address")
        return await self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or Transaction,
        )

    async def check_pending_charge(
        self,
        reference: str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[Transaction] | Response[PaystackDataModel]:
        """
        When you get "pending" as a charge status or if there was an
        exception when calling any of the /charge endpoints, wait 10
        seconds or more, then make a check to see if its status has changed.
        Don't call too early as you may get a lot more pending than you should.

        Args:
            reference: The reference to check
            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"/charge/{reference}")
        return await self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or Transaction,
        )

charge(email, amount, bank=None, bank_transfer=None, auth_code=None, pin=None, metadata=None, reference=None, ussd=None, mobile_money=None, device_id=None, alternate_model_class=None) async

Initiate a payment by integrating the payment channel of your choice.

Parameters:

Name Type Description Default
email str

Customer's email address

 required
amount int

Amount should be in kobo if currency is NGN, pesewas, if currency is GHS, and cents, if currency is ZAR

 required
bank dict[str, Any] | None

Bank account to charge (don't send if charging an authorization code)

 None
bank_transfer dict[str, Any] | None

Takes the settings for the Pay with Transfer (PwT) channel. Pass in the account_expires_at param to set the expiry time.

 None
auth_code str | None

An authorization code to charge (don't send if charging a bank account)

 None
pin str | None

4-digit PIN (send with a non-reusable authorization code)

 None
metadata dict[str, Any] | None

A dictionary of data.

 None
reference str | None

Unique transaction reference. Only -, .`, = and alphanumeric characters allowed.

 None
ussd dict[str, Any] | None

USSD type to charge (don't send if charging an authorization code, bank or card)

 None
mobile_money dict[str, Any] | None

Mobile details (don't send if charging an authorization code, bank or card)

 None
device_id str | None

This is the unique identifier of the device a user uses in making payment. Only -, .`, = and alphanumeric characters allowed.

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/async_clients/charge.py 
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
async def charge(
    self,
    email: str,
    amount: int,
    bank: dict[str, Any] | None = None,
    bank_transfer: dict[str, Any] | None = None,
    auth_code: str | None = None,
    pin: str | None = None,
    metadata: dict[str, Any] | None = None,
    reference: str | None = None,
    ussd: dict[str, Any] | None = None,
    mobile_money: dict[str, Any] | None = None,
    device_id: str | None = None,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Initiate a payment by integrating the payment channel of your choice.

    Args:
        email: Customer's email address
        amount: Amount should be in kobo if currency is NGN, pesewas, if currency is GHS,
            and cents, if currency is ZAR
        bank: Bank account to charge (don't send if charging an authorization code)
        bank_transfer: Takes the settings for the Pay with Transfer (PwT) channel. Pass in the
            account_expires_at param to set the expiry time.
        auth_code: An authorization code to charge (don't send if charging a bank account)
        pin: 4-digit PIN (send with a non-reusable authorization code)
        metadata: A dictionary of data.
        reference: Unique transaction reference. Only -, .\\`, = and alphanumeric characters allowed.
        ussd: USSD type to charge (don't send if charging an authorization code, bank or card)
        mobile_money: Mobile details (don't send if charging an authorization code, bank or card)
        device_id: This is the unique identifier of the device a user uses in making payment. Only -, .\\`,
            = and alphanumeric characters allowed.
        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 = {"email": email, "amount": amount}
    optional_params = [
        ("bank", bank),
        ("bank_transfer", bank_transfer),
        ("authorization_code", auth_code),
        ("pin", pin),
        ("metadata", metadata),
        ("reference", reference),
        ("ussd", ussd),
        ("mobile_money", mobile_money),
        ("device_id", device_id),
    ]
    payload = add_to_payload(optional_params, payload)
    url = self._full_url("/charge")
    return await self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )

check_pending_charge(reference, alternate_model_class=None) async

When you get "pending" as a charge status or if there was an exception when calling any of the /charge endpoints, wait 10 seconds or more, then make a check to see if its status has changed. Don't call too early as you may get a lot more pending than you should.

Parameters:

Name Type Description Default
reference str

The reference to check

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/async_clients/charge.py 
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
async def check_pending_charge(
    self,
    reference: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """
    When you get "pending" as a charge status or if there was an
    exception when calling any of the /charge endpoints, wait 10
    seconds or more, then make a check to see if its status has changed.
    Don't call too early as you may get a lot more pending than you should.

    Args:
        reference: The reference to check
        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"/charge/{reference}")
    return await self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or Transaction,
    )

set_address(address, reference, city, state, zipcode, alternate_model_class=None) async

Submit address to continue a charge

Parameters:

Name Type Description Default
address str

Address submitted by user

 required
reference str

Reference for ongoing transaction

 required
city str

City submitted by user

 required
state str

State submitted by user

 required
zipcode str

Zipcode submitted by user

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/async_clients/charge.py 
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
async def set_address(
    self,
    address: str,
    reference: str,
    city: str,
    state: str,
    zipcode: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Submit address to continue a charge

    Args:
        address: Address submitted by user
        reference: Reference for ongoing transaction
        city: City submitted by user
        state: State submitted by user
        zipcode: Zipcode submitted by user
        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 = {
        "address": address,
        "reference": reference,
        "city": city,
        "state": state,
        "zip_code": zipcode,
    }
    url = self._full_url("/charge/submit_address")
    return await self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )

submit_birthday(birthday, reference, alternate_model_class=None) async

Submit Birthday when requested

Parameters:

Name Type Description Default
birthday str

Birthday submitted by user. ISO Format e.g. 2016-09-21

 required
reference str

Reference for ongoing transaction

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/async_clients/charge.py 
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
async def submit_birthday(
    self,
    birthday: str,
    reference: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Submit Birthday when requested

    Args:
        birthday: Birthday submitted by user. ISO Format e.g. 2016-09-21
        reference: Reference for ongoing transaction
        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 = {"birthday": birthday, "reference": reference}
    url = self._full_url("/charge/submit_birthday")
    return await self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )

submit_otp(otp, reference, alternate_model_class=None) async

Submit OTP to complete a charge

Parameters:

Name Type Description Default
otp str

OTP submitted by user

 required
reference str

Reference for ongoing transaction

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/async_clients/charge.py 
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
156
157
158
159
160
async def submit_otp(
    self,
    otp: str,
    reference: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Submit OTP to complete a charge

    Args:
        otp: OTP submitted by user
        reference: Reference for ongoing transaction
        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 = {"otp": otp, "reference": reference}
    url = self._full_url("/charge/submit_otp")
    return await self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )

submit_phone(phone, reference, alternate_model_class=None) async

Submit Phone when requested

Parameters:

Name Type Description Default
phone str

Phone submitted by user

 required
reference str

Reference for ongoing transaction

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/async_clients/charge.py 
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
async def submit_phone(
    self,
    phone: str,
    reference: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Submit Phone when requested

    Args:
        phone: Phone submitted by user
        reference: Reference for ongoing transaction
        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 = {"phone": phone, "reference": reference}
    url = self._full_url("/charge/submit_phone")
    return await self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )

submit_pin(pin, reference, alternate_model_class=None) async

Submit PIN to continue a charge

Parameters:

Name Type Description Default
pin str

PIN submitted by user

 required
reference str

Reference for transaction that requested pin

 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[Transaction] | Response[PaystackDataModel]

A pydantic model containing the response gotten from paystack's server.
Source code in src/pypaystack2/sub_clients/async_clients/charge.py 
 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
async def submit_pin(
    self,
    pin: str,
    reference: str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[Transaction] | Response[PaystackDataModel]:
    """Submit PIN to continue a charge

    Args:
        pin: PIN submitted by user
        reference: Reference for transaction that requested pin
        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 = {"pin": pin, "reference": reference}
    url = self._full_url("/charge/submit_pin")
    return await self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or Transaction,
    )