Skip to content

Transfers Asynchronous Endpoints

This Transfers endpoint provides asynchronous methods to interact with the transfers of the authenticated user.

Example usage of the Transfers endpoint object:

import asyncio
from pyrevolut.client import AsyncClient

CREDS_JSON_LOC = "path/to/creds.json"

client = AsyncClient(
    creds_loc=CREDS_JSON_LOC,
    sandbox=True,
)

async def run():
    async with client:
        reasons = await client.Transfers.get_transfer_reasons()
        print(reasons)

asyncio.run(run())

EndpointTransfersAsync

Bases: BaseEndpointAsync

The async Transfers API

Move funds in the same currency between accounts of your business, or make payments to your counterparties.

Source code in pyrevolut/api/transfers/endpoint/asynchronous.py 
 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
class EndpointTransfersAsync(BaseEndpointAsync):
    """The async Transfers API

    Move funds in the same currency between accounts of your business,
    or make payments to your counterparties.
    """

    async def get_transfer_reasons(
        self,
        **kwargs,
    ) -> list[dict] | list[GetTransferReasons.Response]:
        """
        In order to initiate a transfer in certain currencies and countries,
        you must provide a transfer reason.
        With this endpoint you can retrieve all transfer reasons available to your business account
        per country and currency.

        After you retrieve the results, use the appropriate reason code in the transfer_reason_code
        field when making a transfer to a counterparty or creating a payout link.

        Parameters
        ----------
        None

        Returns
        -------
        list[dict] | list[GetTransferReasons.Response]
            A list of transfer reasons.
        """
        endpoint = GetTransferReasons
        path = endpoint.ROUTE
        params = endpoint.Params()

        return await self.client.get(
            path=path,
            response_model=endpoint.Response,
            params=params,
            **kwargs,
        )

    async def create_transfer_to_another_account(
        self,
        request_id: str,
        account_id: UUID,
        counterparty_id: UUID,
        amount: float,
        currency: str,
        counterparty_account_id: UUID | None = None,
        counterparty_card_id: UUID | None = None,
        reference: str | None = None,
        charge_bearer: EnumChargeBearer | None = None,
        transfer_reason_code: EnumTransferReasonCode | None = None,
        **kwargs,
    ) -> dict | CreateTransferToAnotherAccount.Response:
        """
        Make a payment to a counterparty.
        The resulting transaction has the type transfer.

        If you make the payment to another Revolut account, either business or personal,
        the transaction is executed instantly.

        If the counterparty has multiple payment methods available, for example, 2 accounts,
        or 1 account and 1 card, you must specify the account or card to which you want to
        transfer the money (receiver.account_id or receiver.card_id respectively).

        Caution
        -------
        Due to PSD2 Strong Customer Authentication regulations, this endpoint is
        only available for customers on Revolut Business Company plans. If you're a
        freelancer and wish to make payments via our API, we advise that you instead
        leverage our Payment drafts (/payment-drafts) endpoint.

        Parameters
        ----------
        request_id : str
            The ID of the request, provided by you.
            It helps you identify the transaction in your system.
            To ensure that a transfer is not processed multiple times if
            there are network or system errors, the same request_id should be used
            for requests related to the same transfer.
        account_id : UUID
            The ID of the account that you transfer the funds from.
        counterparty_id : UUID
            The ID of the receiving counterparty.
        amount : float
            The amount of money to transfer.
        currency : str
            The currency of the transfer.
        counterparty_account_id : UUID, optional
            The ID of the receiving counterparty's account, which can be own account.
            Used for bank transfers.
            If the counterparty has multiple payment methods available, use it to
            specify the account to which you want to send the money.
        counterparty_card_id : UUID, optional
            The ID of the receiving counterparty's card. Used for card transfers.
            If the counterparty has multiple payment methods available, use it to
            specify the card to which you want to send the money.
        reference : str, optional
            A reference for the transfer.
        charge_bearer : EnumChargeBearer, optional
            The party to which any transaction fees are charged if the resulting
            transaction route has associated fees. Some transactions with fees might
            not be possible with the specified option, in which case error 3287 is returned.

            Possible values:
            - shared: The transaction fees are shared between the sender and the receiver.
            - debtor: The sender pays the transaction fees.
        transfer_reason_code : EnumTransferReasonCode, optional
            The reason code for the transaction.
            Transactions to certain countries and currencies might require
            you to provide a transfer reason.
            You can check available reason codes with the getTransferReasons operation.

            If a transfer reason is not required for the given currency and country,
            this field is ignored.

        Returns
        -------
        dict | CreateTransferToAnotherAccount.Response
            The details of the transfer.
        """
        endpoint = CreateTransferToAnotherAccount
        path = endpoint.ROUTE
        body = endpoint.Body(
            request_id=request_id,
            account_id=account_id,
            receiver=endpoint.Body.ModelReceiver(
                counterparty_id=counterparty_id,
                account_id=counterparty_account_id,
                card_id=counterparty_card_id,
            ),
            amount=amount,
            currency=currency,
            reference=reference,
            charge_bearer=charge_bearer,
            transfer_reason_code=transfer_reason_code,
        )

        return await self.client.post(
            path=path,
            response_model=endpoint.Response,
            body=body,
            **kwargs,
        )

    async def move_money_between_accounts(
        self,
        request_id: str,
        source_account_id: UUID,
        target_account_id: UUID,
        amount: float,
        currency: str,
        reference: str | None = None,
        **kwargs,
    ) -> dict | MoveMoneyBetweenAccounts.Response:
        """
        Move money between the Revolut accounts of the business in the same currency.

        The resulting transaction has the type transfer.

        Parameters
        ----------
        request_id : str
            The ID of the request, provided by you.
            It helps you identify the transaction in your system.
            To ensure that a transfer is not processed multiple times if
            there are network or system errors, the same request_id should be used
            for requests related to the same transfer.
        source_account_id : UUID
            The ID of the source account that you transfer the funds from.
        target_account_id : UUID
            The ID of the target account that you transfer the funds to.
        amount : float
            The amount of the funds to be transferred.
        currency : str
            The ISO 4217 currency of the funds to be transferred.
        reference : str, optional
            The reference for the funds transfer.

        Returns
        -------
        dict | MoveMoneyBetweenAccounts.Response
            The details of the transfer.
        """
        endpoint = MoveMoneyBetweenAccounts
        path = endpoint.ROUTE
        body = endpoint.Body(
            request_id=request_id,
            source_account_id=source_account_id,
            target_account_id=target_account_id,
            amount=amount,
            currency=currency,
            reference=reference,
        )

        return await self.client.post(
            path=path,
            response_model=endpoint.Response,
            body=body,
            **kwargs,
        )

create_transfer_to_another_account(request_id, account_id, counterparty_id, amount, currency, counterparty_account_id=None, counterparty_card_id=None, reference=None, charge_bearer=None, transfer_reason_code=None, **kwargs) async

Make a payment to a counterparty. The resulting transaction has the type transfer.

If you make the payment to another Revolut account, either business or personal, the transaction is executed instantly.

If the counterparty has multiple payment methods available, for example, 2 accounts, or 1 account and 1 card, you must specify the account or card to which you want to transfer the money (receiver.account_id or receiver.card_id respectively).

Caution

Due to PSD2 Strong Customer Authentication regulations, this endpoint is only available for customers on Revolut Business Company plans. If you're a freelancer and wish to make payments via our API, we advise that you instead leverage our Payment drafts (/payment-drafts) endpoint.

Parameters:

Name Type Description Default
request_id str

The ID of the request, provided by you. It helps you identify the transaction in your system. To ensure that a transfer is not processed multiple times if there are network or system errors, the same request_id should be used for requests related to the same transfer.

 required
account_id UUID

The ID of the account that you transfer the funds from.

 required
counterparty_id UUID

The ID of the receiving counterparty.

 required
amount float

The amount of money to transfer.

 required
currency str

The currency of the transfer.

 required
counterparty_account_id UUID

The ID of the receiving counterparty's account, which can be own account. Used for bank transfers. If the counterparty has multiple payment methods available, use it to specify the account to which you want to send the money.

 None
counterparty_card_id UUID

The ID of the receiving counterparty's card. Used for card transfers. If the counterparty has multiple payment methods available, use it to specify the card to which you want to send the money.

 None
reference str

A reference for the transfer.

 None
charge_bearer EnumChargeBearer

The party to which any transaction fees are charged if the resulting transaction route has associated fees. Some transactions with fees might not be possible with the specified option, in which case error 3287 is returned.

Possible values: - shared: The transaction fees are shared between the sender and the receiver. - debtor: The sender pays the transaction fees.

 None
transfer_reason_code EnumTransferReasonCode

The reason code for the transaction. Transactions to certain countries and currencies might require you to provide a transfer reason. You can check available reason codes with the getTransferReasons operation.

If a transfer reason is not required for the given currency and country, this field is ignored.

 None

Returns:

Type Description
dict | Response

The details of the transfer.
Source code in pyrevolut/api/transfers/endpoint/asynchronous.py 
 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
async def create_transfer_to_another_account(
    self,
    request_id: str,
    account_id: UUID,
    counterparty_id: UUID,
    amount: float,
    currency: str,
    counterparty_account_id: UUID | None = None,
    counterparty_card_id: UUID | None = None,
    reference: str | None = None,
    charge_bearer: EnumChargeBearer | None = None,
    transfer_reason_code: EnumTransferReasonCode | None = None,
    **kwargs,
) -> dict | CreateTransferToAnotherAccount.Response:
    """
    Make a payment to a counterparty.
    The resulting transaction has the type transfer.

    If you make the payment to another Revolut account, either business or personal,
    the transaction is executed instantly.

    If the counterparty has multiple payment methods available, for example, 2 accounts,
    or 1 account and 1 card, you must specify the account or card to which you want to
    transfer the money (receiver.account_id or receiver.card_id respectively).

    Caution
    -------
    Due to PSD2 Strong Customer Authentication regulations, this endpoint is
    only available for customers on Revolut Business Company plans. If you're a
    freelancer and wish to make payments via our API, we advise that you instead
    leverage our Payment drafts (/payment-drafts) endpoint.

    Parameters
    ----------
    request_id : str
        The ID of the request, provided by you.
        It helps you identify the transaction in your system.
        To ensure that a transfer is not processed multiple times if
        there are network or system errors, the same request_id should be used
        for requests related to the same transfer.
    account_id : UUID
        The ID of the account that you transfer the funds from.
    counterparty_id : UUID
        The ID of the receiving counterparty.
    amount : float
        The amount of money to transfer.
    currency : str
        The currency of the transfer.
    counterparty_account_id : UUID, optional
        The ID of the receiving counterparty's account, which can be own account.
        Used for bank transfers.
        If the counterparty has multiple payment methods available, use it to
        specify the account to which you want to send the money.
    counterparty_card_id : UUID, optional
        The ID of the receiving counterparty's card. Used for card transfers.
        If the counterparty has multiple payment methods available, use it to
        specify the card to which you want to send the money.
    reference : str, optional
        A reference for the transfer.
    charge_bearer : EnumChargeBearer, optional
        The party to which any transaction fees are charged if the resulting
        transaction route has associated fees. Some transactions with fees might
        not be possible with the specified option, in which case error 3287 is returned.

        Possible values:
        - shared: The transaction fees are shared between the sender and the receiver.
        - debtor: The sender pays the transaction fees.
    transfer_reason_code : EnumTransferReasonCode, optional
        The reason code for the transaction.
        Transactions to certain countries and currencies might require
        you to provide a transfer reason.
        You can check available reason codes with the getTransferReasons operation.

        If a transfer reason is not required for the given currency and country,
        this field is ignored.

    Returns
    -------
    dict | CreateTransferToAnotherAccount.Response
        The details of the transfer.
    """
    endpoint = CreateTransferToAnotherAccount
    path = endpoint.ROUTE
    body = endpoint.Body(
        request_id=request_id,
        account_id=account_id,
        receiver=endpoint.Body.ModelReceiver(
            counterparty_id=counterparty_id,
            account_id=counterparty_account_id,
            card_id=counterparty_card_id,
        ),
        amount=amount,
        currency=currency,
        reference=reference,
        charge_bearer=charge_bearer,
        transfer_reason_code=transfer_reason_code,
    )

    return await self.client.post(
        path=path,
        response_model=endpoint.Response,
        body=body,
        **kwargs,
    )

get_transfer_reasons(**kwargs) async

In order to initiate a transfer in certain currencies and countries, you must provide a transfer reason. With this endpoint you can retrieve all transfer reasons available to your business account per country and currency.

After you retrieve the results, use the appropriate reason code in the transfer_reason_code field when making a transfer to a counterparty or creating a payout link.

Parameters:

Name Type Description Default
None
required

Returns:

Type Description
list[dict] | list[Response]

A list of transfer reasons.
Source code in pyrevolut/api/transfers/endpoint/asynchronous.py 
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
async def get_transfer_reasons(
    self,
    **kwargs,
) -> list[dict] | list[GetTransferReasons.Response]:
    """
    In order to initiate a transfer in certain currencies and countries,
    you must provide a transfer reason.
    With this endpoint you can retrieve all transfer reasons available to your business account
    per country and currency.

    After you retrieve the results, use the appropriate reason code in the transfer_reason_code
    field when making a transfer to a counterparty or creating a payout link.

    Parameters
    ----------
    None

    Returns
    -------
    list[dict] | list[GetTransferReasons.Response]
        A list of transfer reasons.
    """
    endpoint = GetTransferReasons
    path = endpoint.ROUTE
    params = endpoint.Params()

    return await self.client.get(
        path=path,
        response_model=endpoint.Response,
        params=params,
        **kwargs,
    )

move_money_between_accounts(request_id, source_account_id, target_account_id, amount, currency, reference=None, **kwargs) async

Move money between the Revolut accounts of the business in the same currency.

The resulting transaction has the type transfer.

Parameters:

Name Type Description Default
request_id str

The ID of the request, provided by you. It helps you identify the transaction in your system. To ensure that a transfer is not processed multiple times if there are network or system errors, the same request_id should be used for requests related to the same transfer.

 required
source_account_id UUID

The ID of the source account that you transfer the funds from.

 required
target_account_id UUID

The ID of the target account that you transfer the funds to.

 required
amount float

The amount of the funds to be transferred.

 required
currency str

The ISO 4217 currency of the funds to be transferred.

 required
reference str

The reference for the funds transfer.

 None

Returns:

Type Description
dict | Response

The details of the transfer.
Source code in pyrevolut/api/transfers/endpoint/asynchronous.py 
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
async def move_money_between_accounts(
    self,
    request_id: str,
    source_account_id: UUID,
    target_account_id: UUID,
    amount: float,
    currency: str,
    reference: str | None = None,
    **kwargs,
) -> dict | MoveMoneyBetweenAccounts.Response:
    """
    Move money between the Revolut accounts of the business in the same currency.

    The resulting transaction has the type transfer.

    Parameters
    ----------
    request_id : str
        The ID of the request, provided by you.
        It helps you identify the transaction in your system.
        To ensure that a transfer is not processed multiple times if
        there are network or system errors, the same request_id should be used
        for requests related to the same transfer.
    source_account_id : UUID
        The ID of the source account that you transfer the funds from.
    target_account_id : UUID
        The ID of the target account that you transfer the funds to.
    amount : float
        The amount of the funds to be transferred.
    currency : str
        The ISO 4217 currency of the funds to be transferred.
    reference : str, optional
        The reference for the funds transfer.

    Returns
    -------
    dict | MoveMoneyBetweenAccounts.Response
        The details of the transfer.
    """
    endpoint = MoveMoneyBetweenAccounts
    path = endpoint.ROUTE
    body = endpoint.Body(
        request_id=request_id,
        source_account_id=source_account_id,
        target_account_id=target_account_id,
        amount=amount,
        currency=currency,
        reference=reference,
    )

    return await self.client.post(
        path=path,
        response_model=endpoint.Response,
        body=body,
        **kwargs,
    )