Spot REST Clients¶

class kraken.base_api.SpotClient(key: str = '', secret: str = '', url: str = '', proxy: str | None = None, *, use_custom_exceptions: bool = True)¶

Bases: object

This class is the base for all Spot clients, handles un-/signed requests and returns exception handled results.

With this class you can easily interact with the Kraken Spot API, including trading Spot crypto assets, xStocks, and margin trading.

If you are facing timeout errors on derived clients, you can make use of the TIMEOUT attribute to deviate from the default 10 seconds.

Kraken sometimes rejects requests that are older than a certain time without further information. To avoid this, the session manager creates a new session every 5 minutes.

Parameters:

key (str, optional) – Spot API public key (default: "")
secret (str, optional) – Spot API secret key (default: "")
url (str, optional) – URL to access the Kraken API (default: https://api.kraken.com)
proxy (str, optional) – proxy URL, may contain authentication information

get_nonce() → str¶: Return a new nonce

Handles the requested requests, by sending the request, handling the response, and returning the message or in case of an error the respective Exception.

Parameters:

method (str) – The request method, e.g., GET, POST, PUT, …
uri (str) – The endpoint to send the message
auth (bool) – If the requests needs authentication (default: True)
params (dict, optional) – The query or post parameter of the request (default: None)
extra_params (str | dict, optional) – Additional query or post parameter of the request (default: None)
timeout (int) – Timeout for the request (default: 10)
do_json (bool) – If the params must be “jsonified” - in case of nested dict style
return_raw (bool, optional) – If the response should be returned without parsing. This is used for example when requesting an export of the trade history as .zip archive.
query_str (str, optional) – Add custom values to the query /0/public/Nfts?filter%5Bcollection_id%5D=NCQNABO-XYCA7-JMMSDF&page_size=10

Raises:

kraken.exceptions.KrakenException.* – If the response contains errors

Returns:

The response

Return type:

dict | list | requests.Response

property return_unique_id: str¶

Returns a unique uuid string

Returns:: uuid
Return type:: str

class kraken.base_api.SpotAsyncClient(key: str = '', secret: str = '', url: str = '', proxy: str | None = None, *, use_custom_exceptions: bool = True)¶

Bases: SpotClient

This class provides the base client for accessing the Kraken Spot API using asynchronous requests.

If you are facing timeout errors on derived clients, you can make use of the TIMEOUT attribute to deviate from the default 10 seconds.

Kraken sometimes rejects requests that are older than a certain time without further information. To avoid this, the session manager creates a new session every 5 minutes.

Parameters:

key (str, optional) – Spot API public key (default: "")
secret (str, optional) – Spot API secret key (default: "")
url (str, optional) – URL to access the Kraken API (default: https://api.kraken.com)
proxy (str, optional) – proxy URL, may contain authentication information

async_close() → None¶: Closes the aiohttp session

async close() → None¶: Closes the aiohttp session

get_nonce() → str¶: Return a new nonce

async request(method: str, uri: str, params: dict | None = None, timeout: int = 10, *, auth: bool = True, do_json: bool = False, return_raw: bool = False, query_str: str | None = None, extra_params: str | dict | None = None) → Coroutine¶

Handles the requested requests, by sending the request, handling the response, and returning the message or in case of an error the respective Exception.

Parameters:

method (str) – The request method, e.g., GET, POST, PUT, …
uri (str) – The endpoint to send the message
auth (bool) – If the requests needs authentication (default: True)
params (dict, optional) – The query or post parameter of the request (default: None)
timeout (int) – Timeout for the request (default: 10)
do_json (bool) – If the params must be “jsonified” - in case of nested dict style
return_raw (bool, optional) – If the response should be returned without parsing. This is used for example when requesting an export of the trade history as .zip archive.
query_str (str, optional) – Add custom values to the query /0/public/Nfts?filter%5Bcollection_id%5D=NCQNABO-XYCA7-JMMSDF&page_size=10

Raises:

kraken.exceptions.KrakenException.* – If the response contains errors

Returns:

The response

Return type:

dict | list | aiohttp.ClientResponse

property return_unique_id: str¶

Returns a unique uuid string

Returns:: uuid
Return type:: str

class kraken.spot.User(key: str = '', secret: str = '', url: str = '', proxy: str | None = None)¶

Bases: SpotClient

Class that implements the Kraken Spot User client

Requires the Query funds permission in the API key settings.

Parameters:

key (str, optional) – Spot API public key (default: "")
secret (str, optional) – Spot API secret key (default: "")
url (str, optional) – The URL to access the Kraken API (default: https://api.kraken.com)
proxy (str, optional) – proxy URL, may contain authentication information

Spot User: Create the user client¶

>>> from kraken.spot import User
>>> user = User() # unauthenticated
>>> auth_user = User(key="api-key", secret="secret-key") # authenticated

Spot User: Create the user client as context manager¶

>>> from kraken.spot import User
>>> with User(key="api-key", secret="secret-key") as user:
...     print(user.get_account_balances())

account_transfer(asset: str, amount: str | float, from_: str, to_: str, *, extra_params: dict | None = None) → dict¶

Transfer funds between master and subaccounts. This is currently only available for institutional clients and must be called by the master account.

https://docs.kraken.com/api/docs/rest-api/account-transfer

Parameters:

asset (str) – The asset to transfer
amount (str | float) – The amount of that asset to transfer
from (str) – The source account (IIBAN)
to (str) – The destination account (IIBAN)

Returns:

Success or failure

Return type:

dict

Spot User: Transfer funds between accounts¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.account_transfer(
...     "asset": "XBT",
...     "amount": 1.0,
...     "from": "ABCD 1234 EFGH 5678"
...     "to": "IJKL 0987 MNOP 6543"
... )
{
    'result': {
        'transfer_id': 'TOH3AS2-LPCWR8-JDQGEU',
        'status': 'complete'
    }
}

create_subaccount(username: str, email: str, *, extra_params: dict | None = None) → dict¶

Create a subaccount for trading. This is currently only available for institutional clients.

https://docs.kraken.com/api/docs/rest-api/create-subaccount

Parameters:

username (str) – The username for the new subaccount
email (str) – The E-Mail address for the new subaccount

Returns:

Success or failure

Return type:

dict

Spot User: Create a subaccount¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.create_subaccount(username="user", email="user@domain.com")
{ 'result': True }

delete_export_report(id_: str, type_: str | None = 'delete', *, extra_params: dict | None = None) → dict¶

Delete a report from the Kraken server.

Requires the Export data permission. In addition for exporting trades data the permissions Query open orders & trades and Query closed orders & trades must be set. For exporting ledgers the Query funds and Query ledger entries must be set.

https://docs.kraken.com/api/docs/rest-api/remove-export

Parameters:

id (str) – The id of the report
type (str, optional) – The type of the export, one of: cancel and delete (default: delete)

Returns:

Success or failure

Return type:

dict

Spot User: Delete or cancel the report¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.delete_export_report(id_="GEHI", type_="delete")
{ 'delete': True }

get_account_balance(*, extra_params: dict | None = None) → dict¶

Get the current balances of the user.

Requires the Query funds permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-account-balance

Spot User: Get the account balances¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_account_balances()
{
    'ZUSD': '241983.1415',
    'KFEE': '8020.22',
    'BCH': '0.0000077100',
    'ETHW': '0.0000040',
    'XXLM': '0.00000000',
    'ZEUR': '0.0000',
    'DOT': '32011.21197000',
    ...
}

get_balance(currency: str) → dict¶

Returns the balance and available balance of a given currency.

Requires the Query funds permission in the API key settings.

Parameters:: currency (str) – The currency to get the balances from
Returns:: Dictionary containing the currency (currency as string), balance (including value in orders), and available_balance (amount that is not in orders)
Return type:: dict

Spot User: Get balance¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_balance(currency="EUR")
{
    'currency': 'ZEUR',
    'balance': 6011.2119,
    'available_balance': 4999.0619
}

get_balances(*, extra_params: dict | None = None) → dict¶

Retrieve the user’s asset balances and the the corresponding amount held by open orders.

Requires the Query funds permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-extended-balance

Returns:: Dictionary containing the currency as keys, that hold a dictionary containing the balance key holding the actual balance including the value in orders and the hold_trade key that represents the amount held in open orders.
Return type:: dict

Spot User: Get balances¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_balances()
{
    'XXLM': {
        'balance': '0.00000000', 'hold_trade': '0.00000000'
    },
    'ZEUR': {
        'balance': '500.0000', 'hold_trade': '0.0000'
    },
    'XXBT': {
        'balance': '2.1031709100', 'hold_trade': '0.1401000000'
    },
    'KFEE': {
        'balance': '1407.73', 'hold_trade': '0.00'
    },
    ...
}

Get the 50 latest closed (filled or canceled) orders.

Requires the Query closed orders & trades permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-closed-orders

Parameters:

userref (int, optional) – Filter the results by user reference id
start (int, optional) – Unix timestamp to start the search from
end (int, optional) – Unix timestamp to define the last result to include
ofs (int, optional) – Offset for pagination
closetime (str, optional) – Specify the exact time frame, one of: both, open, close (default: both)
trades (bool) – Include trades related to position into the response or not (default: False)

Spot User: Get the closed orders¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_closed_orders()
{
    'closed': {
        'OBGFYP-XVQNL-P4GMWF': {
            'refid': None,
            'userref': 0,
            'status': 'closed',
            'opentm': 1680698929.9052045,
            'starttm': 0,
            'expiretm': 0,
            'descr': {
                'pair': 'ETHUSD',
                'type': 'buy',
                'ordertype': 'limit',
                'price': '1860.76',
                'price2': '0',
                'leverage': 'none',
                'order': 'buy 0.02000000 ETHUSD @ limit 1860.76',
                'close': ''
            },
            'vol': '0.02000000',
            'vol_exec': '0.02000000',
            'cost': '37.21520',
            'fee': '0.05954',
            'price': '1860.76',
            'stopprice': '0.00000',
            'limitprice': '0.00000',
            'misc': '',
            'oflags': 'fciq',
            'reason': None,
            'closetm': 1680777419.8115675
        },
        'OAUHYR-YCVK6-P22G6P': {
            ...
        }
    }
}

get_export_report_status(report: str, *, extra_params: dict | None = None) → dict¶

Get the status of the current pending report.

https://docs.kraken.com/api/docs/rest-api/export-status

Parameters:: report (str) – Kind of report, one of: trades, ledgers
Returns:: Information about the pending report
Return type:: list[dict]

Example¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> response = user.request_export_report(
...     report="ledgers", description="myLedgers1", format="CSV"
... )
{ 'id': 'GEHI' }
>>> user.get_export_report_status(report="ledgers")
[
    {
        'id': 'GEHI',
        'descr': 'myLedgers1',
        'format': 'CSV',
        'report': 'ledgers',
        'status': 'Queued',
        'aclass': 'currency',
        'fields': 'all',
        'asset': 'all',
        'subtype': 'all',
        'starttm': '1680307200',
        'endtm': '1680855267',
        'createdtm': '1680855267',
        'expiretm': '1682064867',
        'completedtm': '0',
        'datastarttm': '1680307200',
        'dataendtm': '1680855267',
        'flags': '0'
    }
]

get_ledgers(id_: str | list[str], *, trades: bool | None = False, extra_params: dict | None = None) → dict¶

Get information about specific ledeger entries.

Requires the Query funds and Query ledger entries permissions in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-ledgers-info

Parameters:

id (str | list[str]) – Ledger id as string, list of strings, or comma delimited list of ledger ids as string
trades (bool, optional) – Include trades related to a position or not (default: False)

Spot User: Get ledgers¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_ledgers(id_="LKLSX7-VUXD4-HDLK2P")
{
    'LKLSX7-VUXD4-HDLK2P': {
        'aclass': 'currency',
        'amount': '0.00',
        'asset': 'FEE',
        'balance': '8020.22',
        'fee': '5.95',
        'refid': 'TPLJ5E-NONOU-5LH7JL',
        'time': 1680777419.8115911,
        'type': 'trade',
        'subtype': ''
    }
}

Get information about the users ledger entries. 50 results can be returned at a time.

Requires the Query funds and Query ledger entries permissions in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-ledgers

Parameters:

asset (str | list[str]) – The asset(s) to filter for (default: all)
aclass (str) – The asset class (default: currency )
type (str, optional) – Ledger type, one of: all, deposit, withdrawal, trade, margin, rollover, credit, transfer, settled, staking, and sale (default: all)
start (int, optional) – Unix timestamp to start the search from
end (int, optional) – Unix timestamp to define the last result
ofs (int, optional) – Offset for pagination

Spot User: Get ledgers info¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_ledgers_info(asset=["KFEE","EUR","ETH"])
{
    'count': 519,
    'ledger': {
        'LKLSX7-VUXD4-HDLK2P': {
            'aclass': 'currency',
            'amount': '0.00',
            'asset': 'KFEE',
            'balance': '8020.22',
            'fee': '5.95',
            'refid': 'TPLJ5E-NONOU-5LH7JL',
            'time': 1680777419.8115911,
            'type': 'trade',
            'subtype': ''
        },
        'L4BF6E-FIFW7-6UB2CI': { ... },
        ...
    }
}

get_nonce() → str¶: Return a new nonce

get_open_orders(userref: int | None = None, *, trades: bool | None = False, extra_params: dict | None = None) → dict¶

Get information about the open orders.

Requires the Query open orders & trades permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-open-orders

Parameters:

userref (int, optional) – Filter the results by user reference id
trades (bool) – Include trades related to position or not into the response (default: False)

Spot User: Get the open orders¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_open_orders()
{
    'open': {
        'OCUG7Z-4EM5R-7ZCJ47': {
            'refid': None,
            'userref': 0,
            'status':
            'open',
            'opentm': 1680777427.576083,
            'starttm': 0,
            'expiretm': 0,
            'descr': {
                'pair': 'ETHUSD',
                'type': 'buy',
                'ordertype': 'limit',
                'price': '1720.37',
                'price2': '0',
                'leverage': 'none',
                'order': 'buy 0.02000000 ETHUSD @ limit 1720.37',
                'close': ''
            },
            'vol': '0.02000000',
            'vol_exec': '0.00000000',
            'cost': '0.00000',
            'fee': '0.00000',
            'price': '0.00000',
            'stopprice': '0.00000',
            'limitprice': '0.00000',
            'misc': '',
            'oflags': 'fciq'
        },
        'OFZP3V-UMMUJ-6HMRMB': {
            ...
        }
    }
}

Get information about the open margin positions.

Requires the Query open orders & trades permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-open-positions

Parameters:

txid (str | list[str], optional) – Filter by txid or list of txids or comma delimited list of txids as string
consolidation (str, optional) – Consolidate positions by market/pair (default: market)
docalcs (bool, optional) – Include profit and loss calculation into the result (default: False)

Returns:

List of open positions

Return type:

dict

Spot User: Get the open margin positions¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_open_positions()
{
    'TF5GVO-T7ZZ2-6NBKBI': {
        'ordertxid': 'O0SFFP-ABH4R-LOLNFG',
        'posstatus': 'open',
        'pair': 'XXBTZUSD',
        'time': 1618748097.12341,
        'type': 'buy',
        'ordertype': 'limit',
        'cost': '801243.52842',
        'fee': '208.44527',
        'vol': '8.82412861',
        'vol_closed': '0.20200000',
        'margin': '17234.123968',
        'value": '231463.1',
        'net": '+134186.9728',
        'terms": '0.0100% per 4 hours',
        'rollovertm': '1623672637',
        'misc': '',
        'oflags": ''
    }, ...
}

get_order_amends(order_id: str, *, extra_params: dict | None = None) → dict¶

Retrieve information about historical order amends.

Requires the Query open orders & trades and Query closed orders & trades permissions in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-order-amends

Parameters:: order_id – The order_id to filter for.

Spot User: Get order amends¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_order_amends(txid="OVM3PT-56ACO-53SM2T")
{'amends': [], 'count': 0}

Get information about one or more orders.

Requires the Query open orders & trades and Query closed orders & trades permissions in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-orders-info

Parameters:

txid (str | list[str]) – A transaction id of a specific order, a list of txids or a string containing a comma delimited list of txids
userref (int, optional) – Filter results by user reference id
trades (bool, optional) – Include trades in the result or not (default: False)
consolidate_taker (bool, optional) – Consolidate trades by individual taker trades (default: True)

Spot User: Get order information¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_orders_info(txid="OG5IL4-6AR7I-ZAPZEZ")
{
    'OG5IL4-6AR7I-ZAPZEZ': {
        'refid': None,
        'userref': 0,
        'status': 'open',
        'opentm': 1680618712.3723278,
        'starttm': 0,
        'expiretm': 0,
        'descr': {
            'pair': 'MATICUSD',
            'type': 'buy',
            'ordertype': 'limit',
            'price': '1.0922',
            'price2': '0',
            'leverage': 'none',
            'order': 'buy 45.77910000 MATICUSD @ limit 1.0922',
            'close': ''
        },
        'vol': '45.77910000',
        'vol_exec': '0.00000000',
        'cost': '0.000000',
        'fee': '0.000000',
        'price': '0.000000',
        'stopprice': '0.000000',
        'limitprice': '0.000000',
        'misc': '',
        'oflags': 'fciq',
        'reason': None
    }
}
>>> user.get_orders_info(txid=["OAUHYR-YCVK6-P22G6P", "OG5IL4-6AR7I-ZAPZEZ"])
{
    'OAUHYR-YCVK6-P22G6P': {
        'refid': None,
        'userref': 0,
        'status': 'canceled',
        'opentm': 1680618716.4409518,
        'starttm': 0,
        'expiretm': 0,
        'descr': {
            'pair': 'MATICUSD',
            'type': 'buy',
            'ordertype': 'limit',
            'price': '1.0501',
            'price2': '0',
            'leverage': 'none',
            'order': 'buy 47.61450000 MATICUSD @ limit 1.0501',
            'close': ''
        },
        'vol': '47.61450000',
        'vol_exec': '0.00000000',
        'cost': '0.000000',
        'fee': '0.000000',
        'price': '0.000000',
        'stopprice': '0.000000',
        'limitprice': '0.000000',
        'misc': '',
        'oflags': 'fciq',
        'reason': 'User requested',
        'closetm': 1680756419.5768735
    }
}

get_trade_balance(asset: str | None = 'ZUSD', *, extra_params: dict | None = None) → dict¶

Get the summary of all collateral balances.

Requires the Query funds, Query open orders & trades, and Query closed orders & trades permissions in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-trade-balance

Parameters:: asset (str, optional) – The base asset to determine the balances (default: ZUSD)

Spot User: Get the trade balance¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_trade_balance()
{
    'eb': '983691.5512', # Equivalent balance - all currencies combined
    'tb': '322296.9914', # Trade balance - balance of all equity currencies
    'm': '0.0000',       # Margin amount of open positions
    'uv': '0.0000',      # Unexecuted value of partly filled orders/positions
    'n': '0.0000',       # Unrealized net profit/loss of open positions
    'c': '0.0000',       # Cost basis of open positions
    'v': '0.0000',       # Current floating value of open positions
    'e': '983691.5512',  # Equity ( eb + n )
    'mf': '322296.9914'  # Free margin ( tb / initial margin ) * 100
}

get_trade_volume(pair: str | list[str] | None = None, *, fee_info: bool = True, extra_params: dict | None = None) → dict¶

Get the 30-day user specific trading volume in USD.

Requires the Query funds permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-trade-volume

Parameters:

pair (str | list[str], optional) – Asset pair, list of asset pairs or comma delimited list (as string) of asset pairs to filter
fee_info (bool, optional) – Include fee information or not (default: True)

Spot User: Get the 30-day trade volume¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_trade_volume()
{
    'currency': 'ZUSD',
    'volume': '212220.9741',
    'fees': None,
    'fees_maker': None
}
>>> u.get_trade_volume(pair="DOTUSD")
{
    'currency': 'ZUSD',
    'volume': '212243.1210',
    'fees': {
        'DOTUSD': {
            'fee': '0.2200',
            'minfee': '0.1000',
            'maxfee': '0.2200',
            'nextfee': '0.2000',
            'tiervolume': '0.0000',
            'nextvolume': '250000.0000'
        }
    },
    'fees_maker': {
        'DOTUSD': {
            'fee': '0.1200',
            'minfee': '0.0000',
            'maxfee': '0.1200',
            'nextfee': '0.1000',
            'tiervolume': '0.0000',
            'nextvolume': '250000.0000'
        }
    }
}

Get information about the latest 50 trades and fills. Can be paginated.

Requires the Query closed orders & trades permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-trade-history

Parameters:

type (str, optional) – Filter by type of trade, one of: all, any position, closed position, closing position, and no position (default: all)
start (int, optional) – Timestamp or txid to start the search
end (int, optional) – Timestamp or txid to define the last included result
trades (bool, optional) – Include trades related to a position or not (default: False)
consolidate_taker (bool) – Consolidate trades by individual taker trades (default: True)
ledgers (bool) – Include related leger entries for filtered trade (default: False)

Spot User: Get the trade history¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_trades_history()
{
    'count': 630,
    'trades': {
        'TPLJ5E-NONOU-5LH7JL': {
            'ordertxid': 'OBGFYP-XVQNL-P4GMWF',
            'postxid': 'TKH2SE-M7IF5-CFI7LT',
            'pair': 'XETHZUSD',
            'time': 1680777419.8115635,
            'type': 'buy',
            'ordertype': 'limit',
            'price': '1860.76000',
            'cost': '37.21520',
            'fee': '0.05954',
            'vol': '0.02000000',
            'margin': '0.00000',
            'leverage': '0',
            'misc': '',
            'trade_id': 43914718
        },
        'TNGMNU-XQSRA-LKCWOK': { ... },
        ...
    }
}

get_trades_info(txid: str | list[str], *, trades: bool | None = False, extra_params: dict | None = None) → dict¶

Get information about specific trades/filled orders. 20 txids can be queried maximum.

Requires the Query open orders & trades and Query closed orders & trades permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/get-trades-info

Parameters:

txid (str | list[str]) – txid or list of txids or comma delimited list of txids as string
trades (bool) – Include trades related to position in result (default: False)

Spot User: Get the historical trade information¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.get_trades_info(txid="TNGMNU-XQSRA-LKCWOK")
{
    'TNGMNU-XQSRA-LKCWOK': {
        'ordertxid': 'OHAJCS-ON45W-UIXHT7',
        'postxid': 'TKH2SE-M7IF5-CFI7LT',
        'pair': 'XETHZUSD',
        'time': 1680606470.360982,
        'type': 'sell',
        'ordertype': 'limit',
        'price': '1855.16000',
        'cost': '37.10320',
        'fee': '0.05937',
        'vol': '0.02000000',
        'margin': '0.00000',
        'leverage': '0',
        'misc': '',
        'trade_id': 43878042
    }
}

Handles the requested requests, by sending the request, handling the response, and returning the message or in case of an error the respective Exception.

Parameters:

method (str) – The request method, e.g., GET, POST, PUT, …
uri (str) – The endpoint to send the message
auth (bool) – If the requests needs authentication (default: True)
params (dict, optional) – The query or post parameter of the request (default: None)
extra_params (str | dict, optional) – Additional query or post parameter of the request (default: None)
timeout (int) – Timeout for the request (default: 10)
do_json (bool) – If the params must be “jsonified” - in case of nested dict style
return_raw (bool, optional) – If the response should be returned without parsing. This is used for example when requesting an export of the trade history as .zip archive.
query_str (str, optional) – Add custom values to the query /0/public/Nfts?filter%5Bcollection_id%5D=NCQNABO-XYCA7-JMMSDF&page_size=10

Raises:

kraken.exceptions.KrakenException.* – If the response contains errors

Returns:

The response

Return type:

dict | list | requests.Response

Request to export the trades or ledgers of the user.

https://docs.kraken.com/api/docs/rest-api/add-export

Parameters:

report (str) – Kind of report, one of: trades and ledgers
format (str) – The export format of the requesting report, one of CSV and TSV (default: CSV)
fields (str | list[str], optional) – Fields to include in the report (default: all)
starttm (int, optional) – Unix timestamp to start
endtm (int, optional) – Unix timestamp of the last result
timeout (int) – The timeout for that request (default: 10)

Returns:

A dictionary containing the export id

Return type:

dict

Spot User: Request an report export¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> user.request_export_report(
...     report="ledgers", description="myLedgers1", format="CSV"
... )
{ 'id': 'GEHI' }

retrieve_export(id_: str, timeout: int = 10, *, extra_params: dict | None = None) → dict¶

Retrieve the requested report export.

https://docs.kraken.com/api/docs/rest-api/retrieve-export

Parameters:

id (str) – Id of the report that was requested
timeout (int, optional) – Timeout for that request, default: 10 seconds

Returns:

The response - a zipped report

Return type:

requests.Response

Spot User: Save the exported report to CSV¶

>>> from kraken.spot import User
>>> user = User(key="api-key", secret="secret-key")
>>> response = user.request_export_report(
...     report="ledgers", description="myLedgers1", format="CSV"
... )
{ 'id': 'GEHI' }
>>> ledgers_data = user.retrieve_export(id_=response["id"])
>>> with open("myExport.zip", "wb") as file:
...     for chunk in ledgers_data.iter_content(chunk_size=512):
...         if chunk:
...             file.write(chunk)

property return_unique_id: str¶

Returns a unique uuid string

Returns:: uuid
Return type:: str

class kraken.spot.Market(key: str = '', secret: str = '', url: str = '', proxy: str | None = None)¶

Bases: SpotClient

Class that implements the Kraken Spot Market client. Can be used to access the Kraken Spot market data.

Parameters:

key (str, optional) – Spot API public key (default: "")
secret (str, optional) – Spot API secret key (default: "")
url (str, optional) – Alternative URL to access the Kraken API (default: https://api.kraken.com)
proxy (str, optional) – proxy URL, may contain authentication information

Spot Market: Create the market client¶

>>> from kraken.spot import Market
>>> market = Market() # unauthenticated
>>> auth_market = Market(key="api-key", secret="secret-key") # authenticated

Spot Market: Create the market client as context manager¶

>>> from kraken.spot import Market
>>> with Market() as market:
...     print(market.get_assets())

Get information about a single or multiple asset/currency pair(s). If pair is left blank, all currency pairs will be returned.

https://docs.kraken.com/api/docs/rest-api/get-tradable-asset-pairs

This function uses caching. Run get_asset_pairs.cache_clear() to clear.

Parameters:

pair (str | list[str], optional) – Filter by asset pair(s)
info (str, optional) – Filter by info, can be one of: info (all info), leverage (leverage info), fees (fee info), and margin (margin info)

Returns:

Information about the asset pair

Return type:

dict

Spot Market: Get information about tradeable asset pairs¶

>>> from kraken.spot import Market
>>> Market().get_asset_pairs(pair="XBTUSD")
{
    'XXBTZUSD': {
        'altname': 'XBTUSD',
        'wsname': 'XBT/USD',
        'aclass_base': 'currency',
        'base': 'XXBT',
        'aclass_quote': 'currency',
        'quote': 'ZUSD',
        'lot': 'unit',
        'cost_decimals': 5,
        'pair_decimals': 1,
        'lot_decimals': 8,
        'lot_multiplier': 1,
        'leverage_buy': [2, 3, 4, 5],
        'leverage_sell': [2, 3, 4, 5],
        'fees': [
            [0, 0.26], [50000, 0.24], [100000, 0.22],
            [250000, 0.2], [500000, 0.18], [1000000, 0.16],
            [2500000, 0.14], [5000000, 0.12], [10000000, 0.1]
        ],
        'fees_maker': [
            [0, 0.16], [50000, 0.14], [100000, 0.12],
            [250000, 0.1], [500000, 0.08], [1000000, 0.06],
            [2500000, 0.04], [5000000, 0.02], [10000000, 0.0]
        ],
        'fee_volume_currency': 'ZUSD',
        'margin_call': 80,
        'margin_stop': 40,
        'ordermin': '0.0001',
        'costmin': '0.5',
        'tick_size': '0.1',
        'status': 'online',
        'long_position_limit': 270,
        'short_position_limit': 180
    }
}

get_assets(assets: str | list[str] | None = None, aclass: str | None = None, *, extra_params: dict | None = None) → dict¶

Get information about one or more assets. If assets is not specified, all assets will be returned.

https://docs.kraken.com/api/docs/rest-api/get-asset-info

This function uses caching. Run get_assets.cache_clear() to clear.

Parameters:

assets (str | list[str], optional) – Filter by asset(s)
aclass (str, optional) – Filter by asset class

Returns:

Information about the requested assets

Return type:

dict

Spot Market: Get information about the available assets¶

>>> from kraken.spot import Market
>>> market = Market()
>>> market.get_assets(assets="DOT")
{
    'DOT': {
        'aclass': 'currency',
        'altname': 'DOT',
        'decimals': 10,
        'display_decimals': 8,
        'collateral_value': 0.9,
        'status': 'enabled'
    }
}
>>> market.get_assets(assets=["MATIC", "XBT"]) # same as market.get_assets(assets="MATIC,XBT"])
    'MATIC': {
        'aclass': 'currency',
        'altname': 'MATIC',
        'decimals': 10,
        'display_decimals': 5,
        'collateral_value': 0.7,
        'status': 'enabled'
    },
    'XXBT': {
        'aclass': 'currency',
        'altname': 'XBT',
        'decimals': 10,
        'display_decimals': 5,
        'collateral_value': 1.0,
        'status': 'enabled'
    }
}

get_nonce() → str¶: Return a new nonce

get_ohlc(pair: str, interval: int | str = 1, since: int | str | None = None, *, extra_params: dict | None = None) → dict¶

Get the open, high, low, and close data for a specific trading pair. Returns at max 720 time steps per request.

https://docs.kraken.com/api/docs/rest-api/get-ohlc-data

Parameters:

pair (str) – The pair to get the ohlc from
interval (str | int, optional) – the Interval in minutes (default: 1)
since (int | str, optional) – Timestamp to start from (default: None)

Returns:

The OHLC data of a given asset pair

Return type:

dict

Spot Market: Get the OHLC data¶

>>> from kraken.spot import Market
>>> Market().get_ohlc(pair="XBTUSD")
{
    "XXBTZUSD": [
        [
            1680671100,
            "28488.9",
            "28489.0",
            "28488.8",
            "28489.0",
            "28488.9",
            "1.03390376",
            8
        ], ...
    ]
}

get_order_book(pair: str, count: int | None = 100, *, extra_params: dict | None = None) → dict¶

Get the current orderbook of a specified trading pair.

https://docs.kraken.com/api/docs/rest-api/get-order-book

Parameters:

pair (str) – The pair to get the orderbook from
count (int, optional) – Number of asks and bids, must be one of {1..500} (default: 100)

Returns:

Return type:

dict

Spot Market: Get the orderbook¶

>>> from kraken.spot import Market
>>> Market().get_order_book(pair="XBTUSD", count=2)
{
    'XXBTZUSD': {
        'asks': [
            ['28000.00000', '1.091', 1680714417],
            ['28001.00000', '0.001', 1680714413]
        ],
        'bids': [
            ['27999.90000', '2.240', 1680714419],
            ['27999.50000', '0.090', 1680714418]
        ]
    }
}

get_recent_spreads(pair: str, since: str | int | None = None, *, extra_params: dict | None = None) → dict¶

Get the latest spreads for a specific trading pair.

https://docs.kraken.com/api/docs/rest-api/get-recent-spreads

Parameters:

pair (str) – Pair to get the recent spreads
since (str | int, optional) – Filter trades since given timestamp (default: None)

Returns:

The last n spreads of the asset pair

Return type:

dict

Spot Market: Get the recent spreads¶

>>> from kraken.spot import Market
>>> Market().get_recent_spreads(pair="XBTUSD")
{
    "XXBTZUSD": [
        [1680714601, "28015.00000", "28019.40000"],
        [1680714601, "28015.00000", "28017.00000"],
        [1680714601, "28015.00000", "28016.90000"],
        ...
    ]
}

get_recent_trades(pair: str, since: str | int | None = None, count: int | None = None, *, extra_params: dict | None = None) → dict¶

Get the latest trades for a specific trading pair (up to 1000).

https://docs.kraken.com/api/docs/rest-api/get-recent-trades

Parameters:

pair (str) – Pair to get the recent trades
since (str | int, optional) – Filter trades since given timestamp (default: None)
count (int, optional) – The max number of results

Returns:

The last public trades (up to 1000 results)

Return type:

dict

Spot Market: Get the recent trades¶

>>> from kraken.spot import Market
>>> Market().get_recent_trades(pair="XBTUSD")
{
    "XXBTZUSD": [
        ["27980.90000", "0.00071054", 1680712703.2524643, "b", "l", "", 57811127],
        ["27981.00000", "0.03180000", 1680712715.1806278, "b", "l", "", 57811128],
        ["27980.90000", "0.00010000", 1680712715.469506, "s", "m", "", 57811129],
        ...
    ]
}

get_system_status(*, extra_params: dict | None = None) → dict¶

Returns the system status of the Kraken Spot API.

https://docs.kraken.com/api/docs/rest-api/get-system-status

Returns:: Success or failure
Return type:: dict

Spot Market: Get the Kraken API system status¶

>>> from kraken.spot import Market
>>> Market().get_system_status()
{'status': 'online', 'timestamp': '2023-04-05T17:12:31Z'}

get_ticker(pair: str | list[str] | None = None, *, extra_params: dict | None = None) → dict¶

Returns all tickers if pair is not specified - else just the ticker of the pair. Multiple pairs can be specified.

https://docs.kraken.com/api/docs/rest-api/get-ticker-information

Parameters:: pair (str | list[str], optional) – Filter by pair(s)
Returns:: The ticker(s) including ask, bid, close, volume, vwap, high, low, todays open and more
Return type:: dict

Spot Market: Get the ticker(s)¶

>>> from kraken.spot import Market
>>> Market().get_ticker(pair="XBTUSD")
{
    'XXBTZUSD': {
        'a': ['27948.00000', '3', '3.000'],      # ask
        'b': ['27947.90000', '1', '1.000'],      # bid
        'c': ['27947.90000', '0.00842808'],      # last trade close, lot volume
        'v': ['3564.58017484', '4138.93906134'], # volume today and last 24h
        'p': ['28351.31431', '28329.55480'],     # vwap today and last 24h
        't': [33574, 43062],                     # number of trades today and last 24h
        'l': ['27813.10000', '27813.10000'],     # low today and last 24h
        'h': ['28792.30000', '28792.30000'],     # high today and last 24
        'o': '28173.00000'                       # today's opening price
    }
}

Handles the requested requests, by sending the request, handling the response, and returning the message or in case of an error the respective Exception.

Parameters:

method (str) – The request method, e.g., GET, POST, PUT, …
uri (str) – The endpoint to send the message
auth (bool) – If the requests needs authentication (default: True)
params (dict, optional) – The query or post parameter of the request (default: None)
extra_params (str | dict, optional) – Additional query or post parameter of the request (default: None)
timeout (int) – Timeout for the request (default: 10)
do_json (bool) – If the params must be “jsonified” - in case of nested dict style
return_raw (bool, optional) – If the response should be returned without parsing. This is used for example when requesting an export of the trade history as .zip archive.
query_str (str, optional) – Add custom values to the query /0/public/Nfts?filter%5Bcollection_id%5D=NCQNABO-XYCA7-JMMSDF&page_size=10

Raises:

kraken.exceptions.KrakenException.* – If the response contains errors

Returns:

The response

Return type:

dict | list | requests.Response

property return_unique_id: str¶

Returns a unique uuid string

Returns:: uuid
Return type:: str

class kraken.spot.Trade(key: str = '', secret: str = '', url: str = '', proxy: str | None = None)¶

Bases: SpotClient

Class that implements the Kraken Trade Spot client.

Parameters:

key (str, optional) – Spot API public key (default: "")
secret (str, optional) – Spot API secret key (default: "")
url (str, optional) – The URL to access the Kraken API (default: https://api.kraken.com)
proxy (str, optional) – proxy URL, may contain authentication information

Spot Trade: Create the trade client¶

>>> from kraken.spot import Trade
>>> trade = Trade() # unauthenticated
>>> auth_trade = Trade(key="api-key", secret="secret-key") # authenticated

Spot Trade: Create the trade client as context manager¶

>>> from kraken.spot import Trade
>>> with Trade(key="api-key", secret="secret-key") as trade:
...     print(trade.create_order(...))

amend_order(*, extra_params: dict | None = None) → dict¶

Amend/modify an open order.

Requires the Create and modify orders and Cancel & close orders permissions in the API key settings.

https://docs.kraken.com/api/docs/rest-api/amend-order

Spot Trade: Amend order¶

>>> from kraken.spot import Trade
>>> trade = Trade(key="api-key", secret="secret-key")
>>> trade.amend_order(
...     extra_params={
...         "txid": "OVM3PT-56ACO-53SM2T",
...         "limit_price": "105636.9",
...     }
... )

cancel_all_orders(*, extra_params: dict | None = None) → dict¶

Cancel all open orders.

Requires the Cancel/close orders permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/cancel-all-orders

Returns:: Success or failure - Number of closed orders
Return type:: dict

Spot Trade: Cancel all open orders¶

>>> from kraken.spot import Trade
>>> trade = Trade(key="api-key", secret="secret-key")
>>> trade.cancel_all_orders()
{ 'count': 2 }

cancel_all_orders_after_x(timeout: int = 0, *, extra_params: dict | None = None) → dict¶

Cancel all orders after a timeout. This can be used as Dead Man’s Switch.

Requires the Create and modify orders permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/cancel-all-orders-after

Parameters:: timeout (int, optional) – Optional The timeout in seconds, deactivate by passing the default: 0
Returns:: Current time and trigger time
Return type:: dict

Spot Trade: Set the Death Man’s Switch¶

>>> from kraken.spot import Trade
>>> trade = Trade(key="api-key", secret="secret-key")
>>> trade.cancel_all_orders_after_x(timeout=60)
{
    'currentTime': '2023-04-06T06:51:56Z',
    'triggerTime': '2023-04-06T06:52:56Z'
}

cancel_order(txid: str, *, extra_params: dict | None = None) → dict¶

Cancel a specific order by txid. Instead of a transaction id a user reference id can be passed.

Requires the Cancel/close orders permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/cancel-order

Parameters:: txid (str) – Transaction id or comma delimited list of user reference ids to cancel.
Returns:: Success or failure - Number of closed orders
Return type:: dict

Spot Trade: Cancel an order¶

>>> from kraken.spot import Trade
>>> trade = Trade(key="api-key", secret="secret-key")
>>> trade.cancel_order(txid="OAUHYR-YCVK6-P22G6P")
{ 'count': 1 }

cancel_order_batch(orders: list[str | int], *, extra_params: dict | None = None) → dict¶

Cancel a a list of orders by txid or userref

Requires the Cancel/close orders permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/cancel-order-batch

Parameters:: orders (list[str | int]) – List of orders to cancel
Returns:: Success or failure - Number of closed orders
Return type:: dict

Spot Trade: Cancel multiple orders¶

>>> from kraken.spot import Trade
>>> trade = Trade(key="api-key", secret="secret-key")
>>> trade.cancel_order_batch(
...     orders=["OG5IL4-6AR7I-ZAPZEZ", "OAUHYR-YCVK6-P22G6P"]
... )
{ count': 2 }

Create a new order and place it on the market.

Requires the Create and modify orders permission in the API key settings.

If the traded asset is a tokenized asset, extra_params must contain the key “asset_class” with value “tokenized_asset”.

https://docs.kraken.com/api/docs/rest-api/add-order

Parameters:

ordertype (str) – The kind of the order, one of: market, limit, take-profit, stop-loss-limit, take-profit-limit and settle-position (see: https://support.kraken.com/hc/en-us/sections/200577136-Order-types)
side (str) – buy or sell
pair (str) – The asset to trade
volume (str | float) – The volume of the position to create
price (str | float, optional) – The limit price for limit orders and the trigger price for orders with ordertype one of stop-loss, stop-loss-limit, take-profit, and take-profit-limit
price2 (str | float, optional) –
The limit price for stop-loss-limit and take-profit-limit orders The price2 can also be set to absolute or relative changes.
- Prefixed using + or - defines the change in the quote asset
- Prefixed by # is the same as + or - but the sign is set automatically
- The percentage sign (%) can be used to define relative changes.
trigger (str, optional) – What triggers the position of stop-loss, stop-loss-limit, take-profit, and take-profit-limit orders. Will also be used for associated conditional close orders. Kraken will use last if nothing is specified.
leverage (str | float, optional) – The leverage
stptype (str, optional) – Define what cancels the order, one of cancel-newest, cancel-oldest, cancel-both (default: cancel-newest)
oflags (str | list[str], optional) – Order flags like post, fcib, fciq, nomp, viqc (see the referenced Kraken documentation for more information)
timeinforce (str, optional) – how long the order remains in the orderbook, one of: GTC, IOC, GTD (see the referenced Kraken documentation for more information)
displayvol (str | float, optional) – Define how much of the volume is visible in the orderbook (iceberg)
starttim (str, optional) – Unix timestamp or seconds defining the start time (default: "0")
expiretm (str, optional) – Unix timestamp or time in seconds defining the expiration of the order, (default: "0" - i.e., no expiration)
close_ordertype (str, optional) – Conditional close order type, one of: limit, stop-loss, take-profit, stop-loss-limit, take-profit-limit (see the referenced Kraken documentation for more information)
close_price (str | float, optional) – Conditional close price
close_price2 (str | float, optional) – The price2 for the conditional order - see the price2 parameter description
deadline (str, optional) – RFC3339 timestamp + {0..60} seconds that defines when the matching engine should reject the order.
truncate (bool, optional) – If enabled: round the price and volume to Kraken’s maximum allowed decimal places. See https://support.kraken.com/hc/en-us/articles/4521313131540 fore more information about decimals.
reduce_only (bool, optional) – Reduce existing orders (default: False)
validate (bool, optional) – Validate the order without placing on the market (default: False)
userref (int, optional) – User reference id for example to group orders

Raises:

ValueError – If input is not correct

Returns:

The transaction id

Return type:

dict

Spot Trade: Create a market order¶

>>> from kraken.spot import Trade
>>> trade = Trade(key="api-key", secret="secret-key")
>>> trade.create_order(
...     ordertype="market",
...     side="buy",
...     pair="XBTUSD",
...     volume="0.0001"
... )
{
    'txid': ['TNGMNU-XQSRA-LKCWOK'],
    'descr': {
        'order': 'buy 4.00000000 XBTUSD @ limit 23000.0'
    }
}

Spot Trade: Create limit order¶

>>> from kraken.spot import Trade
>>> trade = Trade(key="api-key", secret="secret-key")
>>> trade.create_order(
...     ordertype="limit",
...     side="buy",
...     pair="XBTUSD",
...     volume=4,
...     price=23000,
...     expiretm=121,
...     displayvol=0.5,
...     oflags=["post", "fcib"]
... )
{
    'txid': ['TPPI2H-CUZZ2-EQR2IE'],
    'descr': {
        'order': 'buy 4.0000 XBTUSD @ limit 23000.0'
    }
}

Spot Trade: Create a stop loss order¶

>>> from kraken.spot import Trade
>>> trade = Trade(key="api-key", secret="secret-key")
>>> trade.create_order(
...     ordertype="stop-loss",
...     pair="XBTUSD",
...     volume=20,
...     price=22000,
...     side="buy",
... )
{
    'txid': ['THNUL1-8ZAS5-EEF3A8'],
    'descr': {
        'order': 'buy 20.00000000 XBTUSD @ stop loss 22000.0'
    }
}

Spot Trade: Create stop-loss-limit and take-profit-limit orders¶

''' When the price hits $25000:
   1. A limit buy order will be placed at $24000 with 2x leverage.
   2. When the limit order gets closed/filled at $24000 The
      stop-loss-limit part is done and the tale-profit-limit part
      begins.
   3. When the price hits $27000 a limit order will be placed at
      $26800 to sell 1.2 BTC. This ensures that the asset will be
      sold for $26800 or better.
'''

>>> from kraken.spot import Trade
>>> trade = Trade(key="api-key", secret="secret-key")
>>> from datetime import datetime, timedelta, timezone
>>> deadline = (
...     datetime.now(timezone.utc) + timedelta(seconds=20)
... ).isoformat()
>>> trade.create_order(
...     ordertype="stop-loss-limit",
...     pair="XBTUSD",
...     side="buy",
...     volume=1.2,
...     price=24000,
...     price2=25000,
...     validate=True, # just validate the input, do not place on the market
...     trigger="last",
...     timeinforce="GTC",
...     leverage=4,
...     deadline=deadline,
...     close_ordertype="take-profit-limit",
...     close_price=27000,
...     close_price2=26800,
... )
{
    'descr': {
        'order': 'buy 0.00100000 XBTUSD @ stop loss 24000.0 -> limit
        25000.0 with 2:1 leverage', 'close': 'close position @ take
        profit 27000.0 -> limit 26800.0'
    }
}

''' The price2 and close_price2 can also be set to absolute or
relative changes.
    * Prefixed using "+" or "-" defines the change in the quote
      asset
    * Prefixed by # is the same as "+" and "-" but the sign is set
      automatically
    * The the percentage sign "%" can be used to define relative
      changes.
'''
>>> trade.create_order(
...     ordertype="stop-loss-limit",
...     pair="XBTUSD",
...     side="buy",
...     volume=1.2,
...     price=24000,
...     price2="+1000",
...     validate=True,
...     trigger="last",
...     timeinforce="GTC",
...     close_ordertype="take-profit-limit",
...     close_price=27000,
...     close_price2="#2%",
... )
{
    'descr': {
        'order': 'buy 0.00100000 XBTUSD @ stop loss 24000.0 -> limit
        +1000.0', 'close': 'close position @ take profit 27000.0 ->
        limit -2.0000%'
    }
}

create_order_batch(orders: list[dict], pair: str, deadline: str | None = None, *, validate: bool = False, extra_params: dict | None = None) → dict¶

Create a batch of max 15 orders for a specific asset pair.

Requires the Create and modify orders permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/add-order-batch

Parameters:

orders (list[dict]) – Dictionary of order objects (see the referenced Kraken documentation for more information)
pair (str) – Asset pair to place the orders for
deadline (str, optional) – RFC3339 timestamp + {0..60} seconds that defines when the matching engine should reject the order.
validate (bool, optional) – Validate the orders without placing them. (default: False)

Returns:

Information about the placed orders

Return type:

dict

Spot Trade: Create a batch order¶

>>> from kraken.spot import Trade
>>> trade = Trade(key="api-key", secret="secret-key")
>>> trade.create_order_batch(orders=[
...         {
...             "close": {
...                 "ordertype": "stop-loss-limit",
...                 "price": 21000,
...                 "price2": 20000,
...             },
...             "ordertype": "limit",
...             "price": 25000,
...             "timeinforce": "GTC",
...             "type": "buy",
...             "userref": 16861348843,
...             "volume": 1,
...         },
...         {
...             "ordertype": "limit",
...             "price": 1000000,
...             "timeinforce": "GTC",
...             "type": "sell",
...             "userref": 16861348843,
...             "volume": 2,
...         },
...     ],
...     pair="BTC/USD"
... )
{
    'orders': [{
        'order': 'buy 1 BTCUSD @ limit 25000',
        'txid': 'O5TLGX-DKKTU-WKRAZ5',
        'close': 'close position @ stop loss 21000.0 -> limit 20000.0'
    }, {
        'order': "sell 2 BTCUSD @ limit 1000000',
        'txid': 'OBGFYP-XVQNL-P4GMWF'
    }]
}

Edit an open order.

Requires the Create and modify orders permission in the API key settings.

https://docs.kraken.com/api/docs/rest-api/edit-order

Parameters:

txid (str) – The txid of the order to edit
pair (str) – The asset pair of the order
volume (str | float, optional) – Set a new volume
price (str | float, optional) – Set a new price
price2 (str | float, optional) – Set a new second price
oflags (str | list[str], optional) – Order flags like post, fcib, fciq, nomp, viqc (see the referenced Kraken documentation for more information)
deadline (string) – (see the referenced Kraken documentation for more information)
cancel_response (bool, optional) – See the referenced Kraken documentation for more information
truncate (bool, optional) – If enabled: round the price and volume to Kraken’s maximum allowed decimal places. See https://support.kraken.com/hc/en-us/articles/4521313131540 fore more information about decimals.
validate (bool, optional) – Validate the order without placing on the market (default: False)
userref (int) – User reference id for example to group orders

Returns:

Success or failure

Return type:

dict

Spot Trade: Modify an order¶

>>> from kraken.spot import Trade
>>> trade = Trade(key="api-key", secret="secret-key")
>>> trade.edit_order(txid="OBGFYP-XVQNL-P4GMWF",
...     volume=0.75,
...     pair="XBTUSD",
...     price=1250000
... )
{
    'status': 'ok',
    'txid': 'OFVXHJ-KPQ3B-VS7ELA',
    'originaltxid': 'OBGFYP-XVQNL-P4GMWF',
    'volume': '0.75',
    'price': '1250000',
    'orders_cancelled': 1,
    'descr': {
        'order': 'sell 0.75 XXBTZUSD @ limit 1250000'
    }
}

get_nonce() → str¶: Return a new nonce

Handles the requested requests, by sending the request, handling the response, and returning the message or in case of an error the respective Exception.

Parameters:

method (str) – The request method, e.g., GET, POST, PUT, …
uri (str) – The endpoint to send the message
auth (bool) – If the requests needs authentication (default: True)
params (dict, optional) – The query or post parameter of the request (default: None)
extra_params (str | dict, optional) – Additional query or post parameter of the request (default: None)
timeout (int) – Timeout for the request (default: 10)
do_json (bool) – If the params must be “jsonified” - in case of nested dict style
return_raw (bool, optional) – If the response should be returned without parsing. This is used for example when requesting an export of the trade history as .zip archive.
query_str (str, optional) – Add custom values to the query /0/public/Nfts?filter%5Bcollection_id%5D=NCQNABO-XYCA7-JMMSDF&page_size=10

Raises:

kraken.exceptions.KrakenException.* – If the response contains errors

Returns:

The response

Return type:

dict | list | requests.Response

property return_unique_id: str¶

Returns a unique uuid string

Returns:: uuid
Return type:: str

truncate(amount: Decimal | float | str, amount_type: str, pair: str, asset_class: str = 'currency') → str¶

Kraken only allows volume and price amounts to be specified with a specific number of decimal places, and these vary depending on the currency pair used.

This function converts an amount of a specific type and pair to a string that uses the correct number of decimal places.

This function uses caching. Run truncate.clear_cache() to clear.

Parameters:

amount (Decimal | float | str) – The floating point number to represent
amount_type (str) – What the amount represents. Either "price" or "volume"
pair (str) – The currency pair the amount is in reference to.
asset_class (str, optional) – The asset class of the base currency. Default is "currency". If the traded asset is a tokenized asset, set this to "tokenized_asset".

Raises:

ValueError – If the amount_type is price and the price is less than the costmin.
ValueError – If the amount_type is volume and the volume is less than the ordermin.
ValueError – If no valid amount_type was passed.

Returns:

A string representation of the amount.

Return type:

str

Spot Trade: Truncate¶

>>> print(trade.truncate(
...     amount=0.123456789,
...     amount_type="volume",
...     pair="XBTUSD"
... ))
0.12345678

>>> print(trade.truncate(
...     amount=21123.12849829993,
...     amount_type="price",
...     pair="XBTUSD")
... ))
21123.1

>>> print(trade.truncate(
...     amount=0.1,
...     amount_type="volume",
...     pair="XBTUSD"
... ))
0.10000000

>>> print(trade.truncate(
...     amount=21123,
...     amount_type="price",
...     pair="XBTUSD"
... ))
21123.0

class kraken.spot.Funding(key: str = '', secret: str = '', url: str = '', proxy: str | None = None)¶

Bases: SpotClient

Class that implements the Spot Funding client. Currently there are no funding endpoints that could be accesses without authentication.

Parameters:

key (str, optional) – Spot API public key (default: "")
secret (str, optional) – Spot API secret key (default: "")
url (str, optional) – Alternative URL to access the Kraken API (default: https://api.kraken.com)
proxy (str, optional) – proxy URL, may contain authentication information

Spot Funding: Create the funding client¶

>>> from kraken.spot import Funding
>>> funding = Funding() # unauthenticated
>>> auth_funding = Funding(key="api-key", secret="secret-key") # authenticated

Spot Funding: Create the funding client as context manager¶

>>> from kraken.spot import Funding
>>> with Funding(key="api-key", secret="secret-key") as funding:
...     print(funding.get_deposit_methods(asset="XLM"))

cancel_withdraw(asset: str, refid: str, *, extra_params: dict | None = None) → dict¶

Cancel a requested withdraw. This will only be successful if the withdraw is not being processed so far.

Requires the Withdraw funds API key permissions.

https://docs.kraken.com/api/docs/rest-api/cancel-withdrawal

Parameters:

asset (str) – Asset of the pending withdraw
refid (str) – The reference ID returned the withdraw was requested

Returns:

Success or failure

Return type:

dict

Spot Funding: Cancel Withdraw¶

>>> from kraken.spot import Funding
>>> funding = Funding(key="api-key", secret="secret-key")
>>> funding.cancel_withdraw(asset="DOT", refid="I7KGS6-UFMTTQ-AGBSO6T")
{ 'result': True }

get_deposit_address(asset: str, method: str, *, new: bool | None = False, extra_params: dict | None = None) → list[dict]¶

Get the deposit addresses for a specific asset. New deposit addresses can be generated.

Requires the Deposit funds API key permission.

https://docs.kraken.com/api/docs/rest-api/get-deposit-addresses

Parameters:

asset (str) – Asset being deposited
method (str) – Deposit method name
new (bool, optional) – Generate a new deposit address (default: False)

Returns:

The user and asset specific deposit addresses

Return type:

list[dict]

Spot Funding: Get the available deposit addresses¶

>>> from kraken.spot import Funding
>>> funding = Funding(key="api-key", secret="secret-key")
>>> funding.get_deposit_address(asset="XLM", method="Stellar XLM")
[
    {
        'address': 'GA5XIGA5C7QTPTWXQHY6MCJRMTRZDOSHR6EFIBNDQTCQHG262N4GGKTM',
        'expiretm': '0',
        'new': True,
        'tag': '1668814718654064928'
    }, {
        'address': 'GA5XIGA5C7QTPTWXQHY6MCJRMTRZDOSHR6EFIBNDQTCQHG262N4GGKTM',
        'expiretm': '0',
        'new': True,
        'tag': '1668815609618044006'
    },  ...
]

get_deposit_methods(asset: str, *, extra_params: dict | None = None) → list[dict]¶

Get the available deposit methods for a specific asset.

https://docs.kraken.com/api/docs/rest-api/get-deposit-methods

Parameters:: asset (str) – Asset being deposited
Returns:: List of available deposit methods of the asset
Return type:: list[dict]

Spot Funding: Get the available deposit methods¶

>>> from kraken.spot import Funding
>>> funding = Funding(key="api-key", secret="secret-key")
>>> funding.get_deposit_methods(asset="XLM")
[
    {
        'method': 'Stellar XLM',
        'limit': False,
        'gen-address': True
    }, {
        'method': 'Stellar XLM Multi',
        'limit': False,
        'gen-address': True
    }
]

get_nonce() → str¶: Return a new nonce

Get information about the recent deposit status. The look back period is 90 days and only the last 25 deposits will be returned.

Requires the Query funds and Deposit funds API key permissions.

https://docs.kraken.com/api/docs/rest-api/get-status-recent-deposits

Parameters:

asset (str, optional) – Filter by asset
method (str, optional) – Filter by deposit method
start (str, optional) – Start timestamp
end (str, optional) – End timestamp
cursor (bool | str, default: False) – If bool: dis-/enable paginated responses; if str: cursor for next page

Returns:

The user specific deposit history

Return type:

list[dict] | dict

Spot Funding: Get the recent deposit status¶

>>> from kraken.spot import Funding
>>> funding = Funding(key="api-key", secret="secret-key")
>>> funding.get_recent_deposits_status()
[
    {
        'method': 'Bank Frick (SEPA)',
        'aclass': 'currency',
        'asset': 'ZEUR',
        'refid': 'QDFN2EK-XMFWQ4-GPB7SG',
        'txid': '7702226',
        'info': 'NTSBDEB1XXX',
        'amount': '1000.0000',
        'fee': '0.0000',
        'time': 1680245166,
        'status': 'Success'
    }, {
        'method': 'Bank Frick (SEPA)',
        'aclass': 'currency',
        'asset': 'ZEUR',
        'refid': 'QDFO35O-O4IU7K-ZEP77Y',
        'txid': '7559797',
        'info': 'NTSBDEB1XXX',
        'amount': '500.0000',
        'fee': '0.0000',
        'time': 1677827980,
        'status': 'Success'
    }, {
        'method': 'Ethereum (ERC20)',
        'aclass': 'currency',
        'asset': 'XETH',
        'refid': 'Q5QTWMS-GXER37-ZI4IH6',
        'txid': '0x2abb04dafd3caed53d4f2912651391c53b912cc4bca1f8b30d09a5cebec5c2d6',
        'info': '0x35be16f2340c97c02c0cf4dcd9279f2eaa4a0980',
        'amount': '0.0119328120',
        'fee': '0.0000000000',
        'time': 1672901534,
        'status': 'Success'
    }, ...
]

Get information about the recent withdraw status, including withdraws of the past 90 days but at max 500 results.

https://docs.kraken.com/api/docs/rest-api/get-status-recent-withdrawals

Parameters:

asset (str, optional) – Filter withdraws by asset (default: None)
method (str, optional) – Filter by withdraw method (default: None)
start (str, optional) – Filter by start timestamp
end (str, optional) – Filter by end timestamp
cursor (str | bool, optional) – en-/disable paginated responses via True/False or define the page as str.

Returns:

Withdrawal information

Return type:

list[dict]

Get the recent withdraw status¶

>>> from kraken.spot import Funding
>>> funding = Funding(key="api-key", secret="secret-key")
>>> funding.get_recent_withdraw_status()
[
    {
        'method': 'Polkadot',
        'aclass': 'currency',
        'asset': 'DOT',
        'refid': 'XXXXXX-XXXXXX-HLDRM5',
        'txid': '0x51d9d13ade1c31a138dae81b845f091d1a6cf2e3c1c36d9cf4f7baf905c483e4',
        'info': '16LrqRXyhjBCSfA6kKrdqxPKrZoMEUtmoW4nkx5ZhA374Bp3',
        'amount': '94.39581164',
        'fee': '0.05000000',
        'time': 1677816733,
        'status': 'Success'
    }, ...
]

get_withdrawal_info(asset: str, key: str, amount: str | float, *, extra_params: dict | None = None) → dict¶

Get information about a possible withdraw, including fee and limit information. The key must be the name of the key defined in the account.

Requires the Query funds and Withdraw funds API key permissions.

https://docs.kraken.com/api/docs/rest-api/get-withdrawal-information

Parameters:

asset (str) – Asset to withdraw
key (str) – Withdrawal key name as set up in the user account
amount (str | float) – The amount to withdraw

Returns:

Information about a possible withdraw including the fee and amount.

Return type:

dict

Spot Funding: Get withdrawal information¶

>>> from kraken.spot import Funding
>>> funding = Funding(key="api-key", secret="secret-key")
>>> funding.get_withdrawal_info(
...     asset="DOT",
...     key="MyPolkadotWallet",
...     amount="4"
... )
{
    'method': 'Polkadot',
    'limit': '4.49880000',
    'amount': '3.95000000',
    'fee': '0.05000000'
}

Handles the requested requests, by sending the request, handling the response, and returning the message or in case of an error the respective Exception.

Parameters:

method (str) – The request method, e.g., GET, POST, PUT, …
uri (str) – The endpoint to send the message
auth (bool) – If the requests needs authentication (default: True)
params (dict, optional) – The query or post parameter of the request (default: None)
extra_params (str | dict, optional) – Additional query or post parameter of the request (default: None)
timeout (int) – Timeout for the request (default: 10)
do_json (bool) – If the params must be “jsonified” - in case of nested dict style
return_raw (bool, optional) – If the response should be returned without parsing. This is used for example when requesting an export of the trade history as .zip archive.
query_str (str, optional) – Add custom values to the query /0/public/Nfts?filter%5Bcollection_id%5D=NCQNABO-XYCA7-JMMSDF&page_size=10

Raises:

kraken.exceptions.KrakenException.* – If the response contains errors

Returns:

The response

Return type:

dict | list | requests.Response

property return_unique_id: str¶

Returns a unique uuid string

Returns:: uuid
Return type:: str

wallet_transfer(asset: str, from_: str, to_: str, amount: str | float, *, extra_params: dict | None = None) → dict¶

Transfer assets between the Spot and Futures wallet.

Requires the Withdraw funds API key permissions.

https://docs.kraken.com/api/docs/rest-api/wallet-transfer

Parameters:

asset (str) – Asset to transfer
from (str) – The wallet to withdraw from
to (str) – The wallet to deposit to
amount (str | float) – The amount to transfer

Returns:

The reference id

Return type:

dict

Spot Funding: Wallet Transfer¶

>>> from kraken.spot import Funding
>>> funding = Funding(key="api-key", secret="secret-key")
>>> funding.wallet_transfer(
...     asset="XBT",
...     from_="Spot Wallet",
...     to_="Futures Wallet",
...     amount=0.01
... )
{ 'refid': "ANS1EE5-SKACR4-PENGVP" }

Returns the list of available withdrawal addresses for that user.

Requires the Funds permissions - Query and Funds permissions - Withdraw API key permissions.

Parameters:

asset (Optional[str]) – Filter by asset
aclass (Optional[str]) – Filter by asset class (default: currency)
method (Optional[str]) – Filter by method
key (Optional[str]) – Filter by key
verified (Optional[str]) – List only addresses which are confirmed via E-Mail

Returns:

List of available addresses for withdrawal

Return type:

list[dict]

withdraw_funds(asset: str, key: str, amount: str | float, max_fee: str | None = None, *, extra_params: dict | None = None) → dict¶

Create a new withdraw. The key must be the name of the withdraw key defined in the withdraw section of the Kraken WebUI.

Requires the Withdraw funds API key permissions.

https://docs.kraken.com/api/docs/rest-api/withdraw-funds

Parameters:

asset (str) – Asset to withdraw
key (str) – Withdrawal key name as set up in the account
amount (str | float) – The amount to withdraw
max_fee (str) – Fail withdraw if the fee will be higher than the specified max_fee.

Returns:

The reference id of the withdraw

Return type:

dict

Spot Funding: Withdraw Funds¶

>>> from kraken.spot import Funding
>>> funding = Funding(key="api-key", secret="secret-key")
>>> funding.withdraw_funds(
...    asset="DOT",
...    key="MyPolkadotWallet"
...    amount=4
... )
{'refid': 'I7KGS6-UFMTTQ-AGBSO6T'}

withdraw_methods(asset: str | None = None, aclass: str | None = None, network: str | None = None, *, extra_params: dict | None = None) → dict¶

Returns the list of available withdraw methods for that user.

Requires the Funds permissions - Query and Funds permissions - Withdraw API key permissions.

Parameters:

asset (Optional[str]) – Filter by asset
aclass (Optional[str]) – Filter by asset class (default: currency)
network (Optional[str]) – Filter by network

Returns:

List of available withdraw methods

Return type:

list[dict]

class kraken.spot.Earn(key: str = '', secret: str = '', url: str = '', proxy: str | None = None)¶

Bases: SpotClient

Class that implements the Kraken Spot Earn client. Currently there are no earn endpoints that could be accesses without authentication.

Parameters:

key (str, optional) – Spot API public key (default: "")
secret (str, optional) – Spot API secret key (default: "")
url (str, optional) – Alternative URL to access the Kraken API (default: https://api.kraken.com)
proxy (str, optional) – proxy URL, may contain authentication information

Spot Earn: Create the Earn client¶

>>> from kraken.spot import Earn
>>> earn = Earn() # unauthenticated
>>> auth_earn = Earn(key="api-key", secret="secret-key") # authenticated

Spot Earn: Create the earn client as context manager¶

>>> from kraken.spot import Earn
>>> with Earn(key="api-key", secret="secret-key") as earn:
...     print(earn.stake_asset(asset="XLM", amount=200, method="Lumen Staked"))

allocate_earn_funds(amount: str | float, strategy_id: str, *, extra_params: dict | None = None) → bool¶

Allocate funds according to the defined strategy.

Requires the Earn Funds API key permission

https://docs.kraken.com/api/docs/rest-api/allocate-strategy

Parameters:

amount (str | float) – The amount to allocate
strategy_id (str) – Identifier of th chosen earn strategy (see kraken.spot.Earn.list_earn_strategies())

Spot Earn: Allocate funds¶

>>> from kraken.earn import Earn
>>> earn = Earn(key="api-key", secret="secret-key")
>>> earn.allocate_earn_funds(
...     amount=2000,
...     strategy_id="ESRFUO3-Q62XD-WIOIL7"
... )
True

deallocate_earn_funds(amount: str | float, strategy_id: str, *, extra_params: dict | None = None) → bool¶

Deallocate funds according to the defined strategy.

Requires the Earn Funds API key permission

https://docs.kraken.com/api/docs/rest-api/deallocate-strategy

Parameters:

amount (str | float) – The amount to deallocate
strategy_id (str) – Identifier of th chosen earn strategy (see kraken.spot.Earn.list_earn_strategies())

Spot Earn: Deallocate funds¶

>>> from kraken.earn import Earn
>>> earn = Earn(key="api-key", secret="secret-key")
>>> earn.deallocate_earn_funds(
...     amount=2000,
...     strategy_id="ESRFUO3-Q62XD-WIOIL7"
... )
True

get_allocation_status(strategy_id: str, *, extra_params: dict | None = None) → dict¶

Retrieve the status of the last allocation request.

Requires the Earn Funds or Query Funds API key permission.

https://docs.kraken.com/api/docs/rest-api/get-allocate-strategy-status

Parameters:: strategy_id (str) – Identifier of th chosen earn strategy (see kraken.spot.Earn.list_earn_strategies())

Spot Earn: Allocation Status¶

>>> from kraken.earn import Earn
>>> earn = Earn(key="api-key", secret="secret-key")
>>> earn.get_allocation_status(
...     strategy_id="ESRFUO3-Q62XD-WIOIL7"
... )
{'pending': False}

get_deallocation_status(strategy_id: str, *, extra_params: dict | None = None) → dict¶

Retrieve the status of the last deallocation request.

Requires the Earn Funds or Query Funds API key permission.

https://docs.kraken.com/api/docs/rest-api/get-deallocate-strategy-status

Parameters:: strategy_id (str) – Identifier of th chosen earn strategy (see kraken.spot.Earn.list_earn_strategies())

Spot Earn: Deallocation Status¶

>>> from kraken.earn import Earn
>>> earn = Earn(key="api-key", secret="secret-key")
>>> earn.get_deallocation_status(
...     strategy_id="ESRFUO3-Q62XD-WIOIL7"
... )
{'pending': False}

get_nonce() → str¶: Return a new nonce

list_earn_allocations(ascending: str | None = None, hide_zero_allocations: str | None = None, converted_asset: str | None = None, *, extra_params: dict | None = None) → dict¶

List the user’s allocations.

Requires the Query Funds API key permission.

https://docs.kraken.com/api/docs/rest-api/list-allocations

(March 9, 2024): The endpoint is not fully implemented on the side of Kraken. Some errors may happen.

Parameters:

ascending (bool, optional) – Sort ascending, defaults to False
hide_zero_allocations (bool, optional) – Hide past allocations without balance, defaults to False
coverted_asset (str, optional) – Currency to express the value of the allocated asset, defaults to None

Spot Earn: List Earn Allocations¶

>>> from kraken.earn import Earn
>>> earn = Earn(key="api-key", secret="secret-key")
>>> earn.list_earn_allocations(asset="DOT")
{
"converted_asset": "USD",
    "total_allocated": "49.2398",
    "total_rewarded": "0.0675",
    "next_cursor": "2",
    "items": [{
        "strategy_id": "ESDQCOL-WTZEU-NU55QF",
        "native_asset": "ETH",
        "amount_allocated": {},
        "total_rewarded": {}
    }]
}

List the available earn strategies as well as additional information.

Requires an API key but no special permission set.

https://docs.kraken.com/api/docs/rest-api/list-strategies

(March 9, 2024): The endpoint is not fully implemented on the side of Kraken. Some errors may happen.

Parameters:

asset (Optional[str], optional) – Asset to filter for, defaults to None
limit (Optional[int], optional) – Items per page, defaults to None
lock_type (Optional[list[str]], optional) – Filter strategies by lock type (flex, bounded, timed, instant), defaults to None
cursor (Optional[bool], optional) – Page ID, defaults to None
ascending (bool, optional) – Sort ascending, defaults to False

Spot Earn: List Earn Strategies¶

>>> from kraken.earn import Earn
>>> earn = Earn(key="api-key", secret="secret-key")
>>> earn.list_earn_strategies(asset="DOT")
{
    "next_cursor": None,
    "items": [
        {
            "id": "ESMWVX6-JAPVY-23L3CV",
            "asset": "DOT",
            "lock_type": {
                "type": "bonded",
                "payout_frequency": 604800,
                "bonding_period": 0,
                "bonding_period_variable": False,
                "bonding_rewards": False,
                "unbonding_period": 2419200,
                "unbonding_period_variable": False,
                "unbonding_rewards": False,
                "exit_queue_period": 0,
            },
            "apr_estimate": {"low": "15.0000", "high": "21.0000"},
            "user_min_allocation": "0.01",
            "allocation_fee": "0.0000",
            "deallocation_fee": "0.0000",
            "auto_compound": {"type": "enabled"},
            "yield_source": {"type": "staking"},
            "can_allocate": True,
            "can_deallocate": True,
            "allocation_restriction_info": [],
        },
        {
            "id": "ESRFUO3-Q62XD-WIOIL7",
            "asset": "DOT",
            "lock_type": {"type": "instant", "payout_frequency": 604800},
            "apr_estimate": {"low": "7.0000", "high": "11.0000"},
            "user_min_allocation": "0.01",
            "allocation_fee": "0.0000",
            "deallocation_fee": "0.0000",
            "auto_compound": {"type": "enabled"},
            "yield_source": {"type": "staking"},
            "can_allocate": True,
            "can_deallocate": True,
            "allocation_restriction_info": [],
        },
    ],
}

Handles the requested requests, by sending the request, handling the response, and returning the message or in case of an error the respective Exception.

Parameters:

method (str) – The request method, e.g., GET, POST, PUT, …
uri (str) – The endpoint to send the message
auth (bool) – If the requests needs authentication (default: True)
params (dict, optional) – The query or post parameter of the request (default: None)
extra_params (str | dict, optional) – Additional query or post parameter of the request (default: None)
timeout (int) – Timeout for the request (default: 10)
do_json (bool) – If the params must be “jsonified” - in case of nested dict style
return_raw (bool, optional) – If the response should be returned without parsing. This is used for example when requesting an export of the trade history as .zip archive.
query_str (str, optional) – Add custom values to the query /0/public/Nfts?filter%5Bcollection_id%5D=NCQNABO-XYCA7-JMMSDF&page_size=10

Raises:

kraken.exceptions.KrakenException.* – If the response contains errors

Returns:

The response

Return type:

dict | list | requests.Response

property return_unique_id: str¶

Returns a unique uuid string

Returns:: uuid
Return type:: str