Spot REST

class kraken.spot.User(key: str = '', secret: str = '', url: str = '')

Bases: KrakenSpotBaseAPI

Class that implements the Kraken Spot User client

Requires the Query funds permission in the API key settings.

• https://docs.kraken.com/rest/#tag/Account-Data

• https://docs.kraken.com/rest/#tag/Subaccounts

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)

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/rest/#tag/User-Subaccounts/operation/accountTransfer

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/rest/#tag/User-Subaccounts

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/rest/#operation/removeExport

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/rest/#operation/getAccountBalance

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.

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_closed_orders(userref: int | None = None, start: int | None = None, end: int | None = None, ofs: int | None = None, closetime: str | None = 'both', *, trades: bool | None = False, extra_params: dict | None = None) → dict

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/rest/#operation/getClosedOrders

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.

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/rest/#operation/exportStatus

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/rest/#operation/getLedgersInfo

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_ledgers_info(asset: str | list[str] | None = 'all', aclass: str | None = 'currency', type_: str | None = 'all', start: int | None = None, end: int | None = None, ofs: int | None = None, *, extra_params: dict | None = None) → dict

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/rest/#operation/getLedgers

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_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/rest/#operation/getOpenOrders

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_open_positions(txid: str | list[str] | None = None, consolidation: str | None = 'market', *, docalcs: bool | None = False, extra_params: dict | None = None) → dict

Get information about the open margin positions.

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

• https://docs.kraken.com/rest/#operation/getOpenPositions

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_orders_info(txid: list[str] | str, userref: int | None = None, *, trades: bool | None = False, consolidate_taker: bool | None = True, extra_params: dict | None = None) → dict

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/rest/#tag/User-Data/operation/getOrdersInfo

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/rest/#operation/getTradeBalance

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/rest/#operation/getTradeVolume

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_trades_history(type_: str | None = 'all', start: int | None = None, end: int | None = None, ofs: int | None = None, *, trades: bool | None = False, consolidate_taker: bool = True, ledgers: bool = False, extra_params: dict | None = None) → dict

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/rest/#operation/getTradeHistory

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/rest/#operation/getTradesInfo

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
    }
}

request_export_report(report: str, description: str, format_: str | None = 'CSV', fields: str | list[str] | None = 'all', starttm: int | None = None, endtm: int | None = None, *, timeout: int | None = 10, extra_params: dict | None = None) → dict

Request to export the trades or ledgers of the user.

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/rest/#operation/addExport

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.

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/rest/#operation/retrieveExport

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 = '')

Bases: KrakenSpotBaseAPI

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

• https://docs.kraken.com/rest/#tag/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)

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_asset_pairs(pair: str | list[str] | None = None, info: str | None = None, *, extra_params: dict | None = None) → dict

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/rest/#operation/getTradableAssetPairs

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/rest/#operation/getAssetInfo

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_ohlc(pair: str, interval: int | str = 1, since: str | int | 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/rest/#operation/getOHLCData

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/rest/#operation/getOrderBook

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/rest/#operation/getRecentSpreads

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/rest/#operation/getRecentTrades

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/rest/#section/General-Usage/Requests-Responses-and-Errors

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/rest/#operation/getTickerInformation

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
    }
}

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 = '')

Bases: KrakenSpotBaseAPI

Class that implements the Kraken Trade Spot client.

• https://docs.kraken.com/rest/#tag/Spot-Trading

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)

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(...))

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/rest/#operation/cancelAllOrders

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/rest/#operation/cancelAllOrdersAfter

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/rest/#operation/cancelOrder

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/rest/#operation/cancelOrderBatch

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_order(ordertype: str, side: str, pair: str, volume: str | float, price: str | float | None = None, price2: str | float | None = None, trigger: str | None = None, leverage: str | None = None, stptype: str | None = 'cancel-newest', oflags: str | list[str] | None = None, timeinforce: str | None = None, displayvol: str | None = None, starttm: str | None = '0', expiretm: str | None = None, close_ordertype: str | None = None, close_price: str | float | None = None, close_price2: str | float | None = None, deadline: str | None = None, userref: int | None = None, *, truncate: bool = False, reduce_only: bool | None = False, validate: bool = False, extra_params: dict | None = None) → dict

Create a new order and place it on the market.

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

• https://docs.kraken.com/rest/#operation/addOrder

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/rest/#operation/addOrderBatch

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_order(txid: str, pair: str, volume: str | float | None = None, price: str | float | None = None, price2: str | float | None = None, oflags: str | None = None, deadline: str | None = None, cancel_response: bool | None = None, userref: int | None = None, *, truncate: bool = False, validate: bool = False, extra_params: dict | None = None) → dict

Edit an open order.

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

• https://docs.kraken.com/rest/#operation/editOrder

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'
    }
}

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) → 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.

• https://support.kraken.com/hc/en-us/articles/4521313131540

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.

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 = '')

Bases: KrakenSpotBaseAPI

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

• https://docs.kraken.com/rest/#tag/Funding

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)

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/rest/#operation/cancelWithdrawal

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/rest/#operation/getDepositAddresses

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/rest/#operation/getDepositMethods

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_recent_deposits_status(asset: str | None = None, method: str | None = None, start: str | None = None, end: str | None = None, cursor: bool | str = False, *, extra_params: dict | None = None) → list[dict] | dict

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/rest/#operation/getStatusRecentDeposits

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_recent_withdraw_status(asset: str | None = None, method: str | None = None, start: str | None = None, end: str | None = None, cursor: str | bool | None = None, *, extra_params: dict | None = None) → list[dict]

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

• https://docs.kraken.com/rest/#operation/getStatusRecentWithdrawals

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. You can add a new key for any asset listed on Kraken here: https://www.kraken.com/u/funding/withdraw.

Requires the Query funds and Withdraw funds API key permissions.

• https://docs.kraken.com/rest/#operation/getWithdrawalInformation

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'
}

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/rest/#operation/walletTransfer

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" }

withdraw_addresses(asset: str | None = None, aclass: str | None = None, method: str | None = None, key: str | None = None, verified: bool | None = None, *, extra_params: dict | None = None) → dict

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/rest/#tag/User-Funding/operation/withdrawFunds

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 = '')

Bases: KrakenSpotBaseAPI

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

• https://docs.kraken.com/rest/#tag/Earn

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)

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/rest/#tag/Earn/operation/allocateStrategy

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/rest/#tag/Earn/operation/deallocateStrategy

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/rest/#tag/Earn/operation/getAllocateStrategyStatus

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/rest/#tag/Earn/operation/getDeallocateStrategyStatus

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}

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/rest/#tag/Earn/operation/listAllocations

(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_earn_strategies(asset: str | None = None, limit: int | None = None, lock_type: list[str] | None = None, cursor: bool | None = None, ascending: bool | None = None, *, extra_params: dict | None = None) → dict

List the available earn strategies as well as additional information.

Requires an API key but no special permission set.

• https://docs.kraken.com/rest/#tag/Earn/operation/listStrategies

(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": [],
        },
    ],
}

property return_unique_id: str

Returns a unique uuid string

Returns:

uuid

Return type:

str

class kraken.spot.Staking(key: str = '', secret: str = '', url: str = '')

Bases: KrakenSpotBaseAPI

Deprecated since version v2.2.0.

Class that implements the Kraken Spot Staking client. Currently there are no staking 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)

• sandbox (bool, optional) – Use the sandbox (not supported for Spot trading so far, default: False)

Spot Staking: Create the staking client

>>> from kraken.spot import Staking
>>> staking = Staking() # unauthenticated
>>> auth_staking = Staking(key="api-key", secret="secret-key") # authenticated

Spot Staking: Create the staking client as context manager

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

get_pending_staking_transactions(*, extra_params: dict | None = None) → list[dict]

Deprecated since version v2.2.0.

Get the list of pending staking transactions of the user.

Requires the Withdraw funds and Query funds API key permissions.

• https://docs.kraken.com/rest/#operation/getStakingPendingDeposits

Returns:

List of pending staking transactions

Return type:

list[dict]

Spot Staking: Get the pending staking transactions

>>> from kraken.spot import Staking
>>> staking = Staking(key="api-key", secret="secret-key")
>>> staking.get_pending_staking_transactions()
[
    {
        'method': 'polkadot-staked',
        'aclass': 'currency',
        'asset': 'DOT.S',
        'refid': 'BOG5AE5-KSCNR4-VPNPEV',
        'amount': '1982.17316',
        'fee': '0.00000000',
        'time': 1623653613,
        'status': 'Initial',
        'type': 'bonding'
    }, ...
]

list_stakeable_assets(*, extra_params: dict | None = None) → list[dict]

Deprecated since version v2.2.0.

Get a list of stakeable assets. Only assets that the user is able to stake will be shown.

Requires the Withdraw funds and Query funds API key permissions.

https://docs.kraken.com/rest/#operation/getStakingAssetInfo

Returns:

Information for all assets that can be staked on Kraken

Return type:

list[dict]

Spot Staking: List the stakeable assets

>>> from kraken.spot import Staking
>>> staking = Staking(key="api-key", secret="secret-key")
>>> staking.list_stakeable_assets()
[
    {
        "method": "polkadot-staked",
        "asset": "DOT",
        "staking_asset": "DOT.S",
        "rewards": {
            "type": "percentage",
            "reward": "7-11"
        },
        "on_chain": True,
        "can_stake": True,
        "can_unstake": True,
        "minimum_amount": {
            "staking": "0.0000000100",
            "unstaking": "0.0000000100"
        }
    }, {
        "method": "polygon-staked",
        "asset": "MATIC",
        "staking_asset": "MATIC.S",
        "rewards": {
            "type": "percentage",
            "reward": "1-2"
        },
        "on_chain": True,
        "can_stake": True,
        "can_unstake": True,
        "minimum_amount": {
            "staking": "0.0000000000",
            "unstaking": "0.0000000000"
        }
    }, ...
]

list_staking_transactions(*, extra_params: dict | None = None) → list[dict]

Deprecated since version v2.2.0.

List the last 1000 staking transactions of the past 90 days.

Requires the Query funds API key permission.

• https://docs.kraken.com/rest/#operation/getStakingTransactions

Returns:

List of historical staking transactions

Return type:

list[dict]

Spot Staking: List the historical staking transactions

>>> from kraken.spot import Staking
>>> staking = Staking(key="api-key", secret="secret-key")
>>> staking.list_staking_transactions()
[
    {
        'method': 'polkadot-staked',
        'aclass': 'currency',
        'asset': 'DOT.S',
        'refid': 'POLZN7T-RWBL2YD-3HAPL1',
        'amount': '121.1',
        'fee': '1.0000000000',
        'time': 1622971496,
        'status': 'Success'.
        'type': 'bonding',
        'bond_start': 1623234684,
        'bond_end': 1632345316
    }, ...
]

property return_unique_id: str

Returns a unique uuid string

Returns:

uuid

Return type:

str

stake_asset(asset: str, amount: str | float, method: str, *, extra_params: dict | None = None) → dict

Deprecated since version v2.2.0.

Stake the specified asset from the Spot wallet.

Requires the Withdraw funds permission in the API key settings.

Have a look at kraken.spot.Staking.list_stakeable_assets() to get information about the stakable assets and methods.

• https://docs.kraken.com/rest/#operation/stake

Parameters:

• asset (str) – The asset to stake

• amount (str | float) – The amount to stake

• method (str) – The staking method

Returns:

The reference id of the staking transaction

Return type:

dict

Spot Staking: Stake an asset

>>> from kraken.spot import Staking
>>> staking = Staking(key="api-key", secret="secret-key")
>>> staking.stake_asset(
...     asset="DOT",
...     amount=2000,
...     method="polkadot-staked"
... )
{ 'refid': 'BOG5AE5-KSCNR4-VPNPEV' }

unstake_asset(asset: str, amount: str | float, method: str | None = None, *, extra_params: dict | None = None) → dict

Deprecated since version v2.2.0.

Unstake an asset and transfer the amount to the Spot wallet.

Requires the Withdraw funds permission in the API key settings.

Have a look at kraken.spot.Staking.list_stakeable_assets() to get information about the stakeable assets and methods.

• https://docs.kraken.com/rest/#operation/unstake

Parameters:

• asset (str) – The asset to stake

• amount (str | float) – The amount to stake

• method (str, optional) – Filter by staking method (default: None)

Returns:

The reference id of the unstaking transaction

Return type:

dict

Spot Staking: Unstake a staked asset

>>> from kraken.spot import Staking
>>> staking = Staking(key="api-key", secret="secret-key")
>>> staking.unstake_asset(
...     asset="DOT",
...     amount=2000,
...     method="polkadot-staked"
... )
{ 'refid': 'BOG5AE5-KSCNR4-VPNPEV' }