Skip to content
Back to search

python-kraken-sdk

Command-line tool, MCP server, and SDK to access the Kraken Crypto Asset Exchange API (Spot, xStocks, and Futures, REST and Websocket API)

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/btschwertfeger--python-kraken-sdk/badge.svg)](/listings/btschwertfeger--python-kraken-sdk)

HTML

<a href="/listings/btschwertfeger--python-kraken-sdk"><img src="/api/listings/btschwertfeger--python-kraken-sdk/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1. Install the package into the desired environment

python3 -m pip install python-kraken-sdk

2. Register at [Kraken](https://www.kraken.com) and generate API keys

- Spot Trading: https://www.kraken.com/u/security/api - Futures Trading: https://futures.kraken.com/trade/settings/api (see _[help](https://docs.futures.kraken.com/#introduction-generate-api-keys)_) - Futures Sandbox: https://demo-futures.kraken.com/settings/api

3. Start using the provided example scripts

4. Error handling

If any unexpected behavior occurs, please check <b style="color: yellow">your API permissions</b>, <b style="color: yellow">rate limits</b>, update the python-kraken-sdk, see the [Troubleshooting](#trouble) section, and if the error persists please open an issue.

<a name="cliusage"></a>

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 622 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <h1 align="center">Spot, xStocks, and Futures REST and Websocket API Python SDK for the Kraken Crypto Asset Exchange 🐙</h1>
  2. <div align="center">
  3. [![GitHub](https://badgen.net/badge/icon/github?icon=github&label)](https://github.com/btschwertfeger/python-kraken-sdk)
  4. [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  5. [![Generic badge](https://img.shields.io/badge/python-3.11+-blue.svg)](https://shields.io/)
  6. [![Downloads](https://static.pepy.tech/personalized-badge/python-kraken-sdk?period=total&units=abbreviation&left_color=grey&right_color=orange&left_text=downloads)](https://pepy.tech/project/python-kraken-sdk)
  7. [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  8. [![Typing](https://img.shields.io/badge/typing-mypy-informational)](https://mypy-lang.org/)
  9. [![CI/CD](https://github.com/btschwertfeger/python-kraken-sdk/actions/workflows/cicd.yaml/badge.svg?branch=master)](https://github.com/btschwertfeger/python-kraken-sdk/actions/workflows/cicd.yaml)
  10. [![codecov](https://codecov.io/gh/btschwertfeger/python-kraken-sdk/branch/master/badge.svg)](https://app.codecov.io/gh/btschwertfeger/python-kraken-sdk)
  11. [![OpenSSF ScoreCard](https://img.shields.io/ossf-scorecard/github.com/btschwertfeger/python-kraken-sdk?label=openssf%20scorecard&style=flat)](https://securityscorecards.dev/viewer/?uri=github.com/btschwertfeger/python-kraken-sdk)
  12. [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/8673/badge)](https://www.bestpractices.dev/projects/8673)
  13. [![release](https://shields.io/github/release-date/btschwertfeger/python-kraken-sdk)](https://github.com/btschwertfeger/python-kraken-sdk/releases)
  14. [![release](https://img.shields.io/pypi/v/python-kraken-sdk)](https://pypi.org/project/python-kraken-sdk/)
  15. [![DOI](https://zenodo.org/badge/510751854.svg)](https://zenodo.org/badge/latestdoi/510751854)
  16. [![Documentation Status Stable](https://readthedocs.org/projects/python-kraken-sdk/badge/?version=stable)](https://python-kraken-sdk.readthedocs.io/en/stable)
  17. </div>
  18. > ⚠️ This is an unofficial collection of REST and websocket clients for Spot and
  19. > Futures trading on the Kraken Crypto Asset Exchange using Python. Payward
  20. > Ltd. and Kraken are in no way associated with the authors of this package and
  21. > documentation.
  22. >
  23. > Please note that this project is independent and not endorsed by Kraken or
  24. > Payward Ltd. Users should be aware that they are using third-party software,
  25. > and the authors of this project are not responsible for any issues, losses, or
  26. > risks associated with its usage.
  27. ## 📌 Disclaimer
  28. There is no guarantee that this software will work flawlessly at this or later
  29. times. Of course, no responsibility is taken for possible profits or losses.
  30. This software probably has some errors in it, so use it at your own risk. Also
  31. no one should be motivated or tempted to invest assets in speculative forms of
  32. investment. By using this software you release the author(s) from any liability
  33. regarding the use of this software.
  34. ---
  35. ## Features
  36. General:
  37. - Command-line interface
  38. - Access both public and private, REST and websocket endpoints
  39. - Responsive error handling and custom exceptions
  40. - Extensive example scripts (see `/examples` and `/tests`)
  41. - Tested using the [pytest](https://docs.pytest.org/en/7.3.x/) framework
  42. - Releases are permanently archived at [Zenodo](https://zenodo.org/badge/latestdoi/510751854)
  43. Available Clients:
  44. - Spot REST Clients - including xStocks capability
  45. - Spot Websocket Client (Websocket API v2)
  46. - Spot Orderbook Client (Websocket API v2)
  47. - Futures REST Clients
  48. - Futures Websocket Client
  49. Documentation:
  50. - [https://python-kraken-sdk.readthedocs.io/en/stable](https://python-kraken-sdk.readthedocs.io/en/stable)
  51. - [https://python-kraken-sdk.readthedocs.io/en/latest](https://python-kraken-sdk.readthedocs.io/en/latest)
  52. Projects using this SDK:
  53. - https://github.com/btschwertfeger/infinity-grid
  54. - https://github.com/btschwertfeger/kraken-rebalance-bot
  55. - https://github.com/btschwertfeger/python-kraken-sdk/network/dependents
  56. ---
  57. ## ❗️ Attention
  58. **ONLY** tagged releases are available at PyPI. So the content of the master may
  59. not match with the content of the latest release. - Please have a look at the
  60. release specific READMEs and changelogs.
  61. It is also recommended to _pin the used version_ to avoid unexpected behavior on
  62. new releases.
  63. ---
  64. ## Table of Contents
  65. - [ Installation and setup ](#installation)
  66. - [ Command-line interface ](#cliusage)
  67. - [ MCP Server ](#mcpusage)
  68. - [ Spot Clients ](#spotusage)
  69. - [ xStocks ](#xstocksusage)
  70. - [ Futures Clients ](#futuresusage)
  71. - [ Troubleshooting ](#trouble)
  72. - [ Contributions ](#contribution)
  73. - [ Notes ](#notes)
  74. - [ Considerations ](#considerations)
  75. - [ References ](#references)
  76. <a name="installation"></a>
  77. # 🛠 Installation and setup
  78. ### 1. Install the package into the desired environment
  79. ```bash
  80. python3 -m pip install python-kraken-sdk
  81. ```
  82. ### 2. Register at [Kraken](https://www.kraken.com) and generate API keys
  83. - Spot Trading: https://www.kraken.com/u/security/api
  84. - Futures Trading: https://futures.kraken.com/trade/settings/api (see _[help](https://docs.futures.kraken.com/#introduction-generate-api-keys)_)
  85. - Futures Sandbox: https://demo-futures.kraken.com/settings/api
  86. ### 3. Start using the provided example scripts
  87. ### 4. Error handling
  88. If any unexpected behavior occurs, please check <b style="color: yellow">your
  89. API permissions</b>, <b style="color: yellow">rate limits</b>, update the
  90. python-kraken-sdk, see the [Troubleshooting](#trouble) section, and if the error
  91. persists please open an issue.
  92. <a name="cliusage"></a>
  93. # 📍 Command-line interface
  94. The python-kraken-sdk provides a command-line interface to access the Kraken API
  95. using basic instructions while performing authentication tasks in the
  96. background. The Spot and Futures API are accessible and follow the pattern
  97. `kraken {spot,futures} [OPTIONS] URL`. See examples below.
  98. ```bash
  99. # get server time
  100. kraken spot https://api.kraken.com/0/public/Time
  101. {'unixtime': 1716707589, 'rfc1123': 'Sun, 26 May 24 07:13:09 +0000'}
  102. # get user's balances
  103. kraken spot --api-key=<api-key> --secret-key=<secret-key> -X POST https://api.kraken.com/0/private/Balance
  104. {'ATOM': '17.28229999', 'BCH': '0.0000077100', 'ZUSD': '1000.0000'}
  105. # get user's trade balances
  106. kraken spot --api-key=<api-key> --secret-key=<secret-key> -X POST https://api.kraken.com/0/private/TradeBalance --data '{"asset": "DOT"}'
  107. {'eb': '2.8987347115', 'tb': '1.1694303513', 'm': '0.0000000000', 'uv': '0', 'n': '0.0000000000', 'c': '0.0000000000', 'v': '0.0000000000', 'e': '1.1694303513', 'mf': '1.1694303513'}
  108. # get 1D candles for a futures instrument
  109. kraken futures https://futures.kraken.com/api/charts/v1/spot/PF_XBTUSD/1d
  110. {'candles': [{'time': 1625616000000, 'open': '34557.84000000000', 'high': '34803.20000000000', 'low': '33816.32000000000', 'close': '33880.22000000000', 'volume': '0' ...
  111. # get user's open futures positions
  112. kraken futures --api-key=<api-key> --secret-key=<secret-key> https://futures.kraken.com/derivatives/api/v3/openpositions
  113. {'result': 'success', 'openPositions': [], 'serverTime': '2024-05-26T07:15:38.91Z'}
  114. ```
  115. ... All endpoints of the Kraken Spot and Futurs API can be accessed like that.
  116. <a name="mcpusage"></a>
  117. # 📍 MCP Server
  118. The python-kraken-sdk also ships an MCP server exposing the Spot (incl.
  119. xStocks — pass `"asset_class": "tokenized_asset"` inside `params` where the
  120. Kraken API docs require it) and Futures `request` methods as two tools,
  121. `spot_request` and `futures_request`.
  122. ```bash
  123. uv tool install "python-kraken-sdk[mcp]"
  124. # e.g. Claude setup:
  125. claude mcp add kraken --scope user -- kraken-mcp
  126. ```
  127. Credentials are never tool arguments. Configure them as environment
  128. variables instead: `KRAKEN_SPOT_API_KEY` / `KRAKEN_SPOT_SECRET_KEY`,
  129. `KRAKEN_FUTURES_API_KEY` / `KRAKEN_FUTURES_SECRET_KEY`, and optionally
  130. `KRAKEN_FUTURES_SANDBOX=1` to target the Futures demo environment. Example
  131. client for Claude Code configuration:
  132. ```json
  133. // ~/.claude.json
  134. {
  135. "mcpServers": {
  136. "kraken": {
  137. "command": "kraken-mcp",
  138. "env": {
  139. // Only public endpoints are available without credentials
  140. "KRAKEN_SPOT_API_KEY": "<your-api-key>",
  141. "KRAKEN_SPOT_SECRET_KEY": "<your-secret-key>"
  142. }
  143. }
  144. }
  145. }
  146. ```
  147. <a name="spotusage"></a>
  148. # 📍 Spot Clients
  149. The python-kraken-sdk provides lots of functions to easily access most of the
  150. REST and websocket endpoints of the Kraken Crypto Asset Exchange API. Since
  151. these endpoints and their parameters may change, all implemented endpoints are
  152. tested on a regular basis.
  153. The Kraken Spot API can be accessed by executing requests to the endpoints
  154. directly using the `request` method provided by any client. This is demonstrated
  155. below.
  156. See https://docs.kraken.com/api/docs/guides/global-intro for information about
  157. the available endpoints and their usage.
  158. ### `SpotClient`
  159. The Spot client provides access to all un-and authenticated endpoints of
  160. Kraken's Spot API.
  161. ```python
  162. from kraken.spot import SpotClient
  163. client = SpotClient(key="<your-api-key>", secret="<your-secret-key>")
  164. print(client.request("POST", "/0/private/Balance"))
  165. ```
  166. ### `SpotAsyncClient`
  167. The async Spot client allows for asynchronous access to Kraken's Spot API
  168. endpoints. Below are two examples demonstrating its usage.
  169. Using SpotAsyncClient without a context manager; In this example, the client is
  170. manually closed after the request is made.
  171. ```python
  172. import asyncio
  173. from kraken.spot import SpotAsyncClient
  174. async def main():
  175. client = SpotAsyncClient(key="<your-api-key>", secret="<your-secret-key>")
  176. try:
  177. response = await client.request("POST", "/0/private/Balance")
  178. print(response)
  179. finally:
  180. await client.close()
  181. if __name__ == "__main__":
  182. asyncio.run(main())
  183. ```
  184. Using SpotAsyncClient as a context manager; This example demonstrates the use of
  185. the context manager, which ensures the client is automatically closed after the
  186. request is completed.
  187. ```python
  188. import asyncio
  189. from kraken.spot import SpotAsyncClient
  190. async def main():
  191. async with SpotAsyncClient(key="<your-api-key>", secret="<your-secret-key>") as client:
  192. response = await client.request("POST", "/0/private/Balance")
  193. print(response)
  194. if __name__ == "__main__":
  195. asyncio.run(main())
  196. ```
  197. <a name="spotws"></a>
  198. ### `SpotWSClient` (Websocket API)
  199. Kraken offers two versions of their websocket API (V1 and V2). Since V2 is
  200. offers more possibilities, is way faster and easier to use, only the never
  201. version is supported by this SDK.
  202. The official documentation for can be found at:
  203. - https://docs.kraken.com/api/docs/guides/global-intro
  204. - https://docs.kraken.com/websockets-v2
  205. Note that authenticated Spot websocket clients can also un-/subscribe from/to
  206. public feeds.
  207. The example below can be found in an extended way in
  208. `examples/spot_ws_examples.py`.
  209. ```python
  210. import asyncio
  211. from kraken.spot import SpotWSClient
  212. class Client(SpotWSClient):
  213. """Can be used to create a custom trading strategy"""
  214. async def on_message(self, message):
  215. """Receives the websocket messages"""
  216. if message.get("method") == "pong" \
  217. or message.get("channel") == "heartbeat":
  218. return
  219. print(message)
  220. # Here we can access lots of methods, for example to create an order:
  221. # if self.is_auth: # only if the client is authenticated …
  222. # await self.send_message(
  223. # message={
  224. # "method": "add_order",
  225. # "params": {
  226. # "limit_price": 1234.56,
  227. # "order_type": "limit",
  228. # "order_userref": 123456789,
  229. # "order_qty": 1.0,
  230. # "side": "buy",
  231. # "symbol": "BTC/USD",
  232. # "validate": True,
  233. # },
  234. # }
  235. # )
  236. # … it is also possible to call regular REST endpoints
  237. # but using the websocket messages is more efficient.
  238. # You can also un-/subscribe here using self.subscribe/self.unsubscribe.
  239. async def main():
  240. try:
  241. # Public/unauthenticated websocket client
  242. client = Client() # only use this one if you don't need private feeds
  243. await client.start()
  244. await client.subscribe(
  245. params={"channel": "ticker", "symbol": ["BTC/USD", "DOT/USD"]}
  246. )
  247. await client.subscribe(
  248. params={"channel": "book", "depth": 25, "symbol": ["BTC/USD"]}
  249. )
  250. # wait because unsubscribing is faster than unsubscribing … (just for that example)
  251. await asyncio.sleep(3)
  252. # print(client.active_public_subscriptions) # to list active subscriptions
  253. await client.unsubscribe(
  254. params={"channel": "ticker", "symbol": ["BTC/USD", "DOT/USD"]}
  255. )
  256. # …
  257. # AS default, the authenticated client starts two websocket connections,
  258. # one for authenticated and one for public messages. If there is no need
  259. # for a public connection, it can be disabled using the ``no_public``
  260. # parameter.
  261. client_auth = Client(key="api-key", secret="secret-key", no_public=True)
  262. await client_auth.start()
  263. await client_auth.subscribe(params={"channel": "balances"})
  264. while not client.exception_occur and not client_auth.exception_occur:
  265. await asyncio.sleep(6)
  266. finally:
  267. await client.close()
  268. await client_auth.close()
  269. if __name__ == "__main__":
  270. asyncio.run(main())
  271. ```
  272. <a name="xstocksusage"></a>
  273. # 📍 xStocks
  274. Kraken recently added support for trading of tokenized stocks (xStocks) on their
  275. platform. The python-kraken-sdk fully supports this new feature, allowing users
  276. to trade xStocks seamlessly alongside other crypto assets.
  277. For accessing xStocks, you can use the same `SpotClient` and `SpotAsyncClient`
  278. classes that are used for regular spot trading. The endpoints and methods for
  279. xStocks are integrated into these clients, making it easy to manage your xStock
  280. trades.
  281. It is important to note that the xStocks feature is not available globally. Please
  282. check Kraken's documentation to understand the availability zones and ensure
  283. that you can trade xStocks from your location.
  284. For trading or filtering for xStocks assets, the new asset class
  285. `tokenized_asset` must be used, e.g. when creating an order:
  286. ```python
  287. from kraken.spot import SpotClient, Trade
  288. # Option 1: Create an order using the SpotClient directly:
  289. client = SpotClient(key="api-public-key", secret="api-secret-key")
  290. client.request(
  291. method="POST",
  292. uri="/0/private/AddOrder",
  293. params={
  294. "type": "buy",
  295. "volume": "1",
  296. "ordertype": "limit",
  297. "pair": "AAPLxUSD",
  298. "price": "100.0",
  299. "validate": True,
  300. "asset_class": "tokenized_asset", # <- important!
  301. },
  302. )
  303. # Option 2: Create an order using the Trade client:
  304. trade = Trade(key="api-public-key", secret="api-secret-key")
  305. trade.create_order(
  306. pair="AAPLxUSD",
  307. side="buy",
  308. ordertype="limit",
  309. volume="1",
  310. price="100.0",
  311. validate=True,
  312. extra_params={"asset_class": "tokenized_asset"}, # <- important!
  313. )
  314. ```
  315. <a name="futuresusage"></a>
  316. # 📍 Futures Clients
  317. The Kraken Spot API can be accessed by executing requests to the endpoints
  318. directly using the `request` method provided by any client. This is demonstrated
  319. below.
  320. See https://docs.kraken.com/api/docs/guides/global-intro for information about
  321. the available endpoints and their usage.
  322. ### `FuturesClient`
  323. The simple Futures client provides access to all un-and authenticated endpoints.
  324. ```python
  325. from kraken.futures import FuturesClient
  326. client = FuturesClient(key="<your-api-key>", secret="<your-secret-key>")
  327. print(client.request("GET", "/derivatives/api/v3/accounts"))
  328. ```
  329. ### `FuturesAsyncClient`
  330. The async Futures client allows for asynchronous access to Kraken's Futures
  331. endpoints. Below are two examples demonstrating its usage.
  332. Using FuturesAsyncClient without a context manager; In this example, the client
  333. is manually closed after the request is made.
  334. ```python
  335. import asyncio
  336. from kraken.futures import FuturesAsyncClient
  337. async def main():
  338. client = FuturesAsyncClient(key="<your-api-key>", secret="<your-secret-key>")
  339. try:
  340. response = await client.request("GET", "/derivatives/api/v3/accounts")
  341. print(response)
  342. finally:
  343. await client.close()
  344. if __name__ == "__main__":
  345. asyncio.run(main())
  346. ```
  347. Using FuturesAsyncClient as context manager; This example demonstrates the use
  348. of the context manager, which ensures the client is automatically closed after
  349. the request is completed.
  350. ```python
  351. import asyncio
  352. from kraken.futures import FuturesAsyncClient
  353. async def main():
  354. async with FuturesAsyncClient(key="<your-api-key>", secret="<your-secret-key>") as client:
  355. response = await client.request("GET", "/derivatives/api/v3/accounts")
  356. print(response)
  357. if __name__ == "__main__":
  358. asyncio.run(main())
  359. ```
  360. <a name="futuresws"></a>
  361. ### `FuturesWSClient` (Websocket API)
  362. Not only REST, also the websocket API for Kraken Futures is available. Examples
  363. are shown below and demonstrated in `examples/futures_ws_examples.py`.
  364. - https://docs.futures.kraken.com/#websocket-api
  365. Note: Authenticated Futures websocket clients can also un-/subscribe from/to
  366. public feeds.
  367. ```python
  368. import asyncio
  369. from kraken.futures import FuturesWSClient
  370. class Client(FuturesWSClient):
  371. async def on_message(self, event):
  372. print(event)
  373. async def main():
  374. try:
  375. # Public/unauthenticated websocket connection
  376. client = Client()
  377. await client.start()
  378. products = ["PF_XBTUSD", "PF_ETHUSD"]
  379. # subscribe to a public websocket feed
  380. await client.subscribe(feed="ticker", products=products)
  381. # await client.subscribe(feed="book", products=products)
  382. # …
  383. # unsubscribe from a public websocket feed
  384. # await client.unsubscribe(feed="ticker", products=products)
  385. # Private/authenticated websocket connection (+public)
  386. client_auth = Client(key="key-key", secret="secret-key")
  387. await client_auth.start()
  388. # print(client_auth.get_available_private_subscription_feeds())
  389. # subscribe to a private/authenticated websocket feed
  390. await client_auth.subscribe(feed="fills")
  391. await client_auth.subscribe(feed="open_positions")
  392. await client_auth.subscribe(feed="open_orders")
  393. # …
  394. # unsubscribe from a private/authenticated websocket feed
  395. await client_auth.unsubscribe(feed="fills")
  396. while not client.exception_occur and not client_auth.exception_occur:
  397. await asyncio.sleep(6)
  398. finally:
  399. await client.close()
  400. await client_auth.close()
  401. if __name__ == "__main__":
  402. asyncio.run(main())
  403. ```
  404. ---
  405. <a name="contribution"></a>
  406. # 🆕 Contributions
  407. … are welcome - but:
  408. - First check if there is an existing issue or PR that addresses your
  409. problem/solution. If not - create one first - before creating a PR.
  410. - Typo fixes, project configuration, CI, documentation or style/formatting PRs
  411. will be rejected. Please create an issue for that.
  412. - PRs must provide a reasonable, easy to understand and maintain solution for an
  413. existing problem. You may want to propose a solution when creating the issue
  414. to discuss the approach before creating a PR.
  415. - Please have a look at [CONTRIBUTION.md](./CONTRIBUTING.md).
  416. ---
  417. <a name="trouble"></a>
  418. # 🚨 Troubleshooting
  419. - Check if you downloaded and installed the **latest version** of the
  420. python-kraken-sdk.
  421. - Check the **permissions of your API keys** and the required permissions on the
  422. respective endpoints.
  423. - If you get some Cloudflare or **rate limit errors**, please check your Kraken
  424. Tier level and maybe apply for a higher rank if required.
  425. - **Use different API keys for different algorithms**, because the nonce
  426. calculation is based on timestamps and a sent nonce must always be the highest
  427. nonce ever sent of that API key. Having multiple algorithms using the same
  428. keys will result in invalid nonce errors.
  429. - Always keep an eye on https://status.kraken.com/ when encountering
  430. connectivity problems.
  431. - The xStocks feature is not available globally. Please checkout Kraken's
  432. documentation to get to know the availability zones.
  433. ---
  434. <a name="notes"></a>
  435. # 📝 Notes
  436. The versioning scheme follows the pattern `v<Major>.<Minor>.<Patch>`. Here's
  437. what each part signifies:
  438. - **Major**: This denotes significant changes that may introduce new features or
  439. modify existing ones. It's possible for these changes to be breaking, meaning
  440. backward compatibility is not guaranteed. To avoid unexpected behavior, it's
  441. advisable to specify at least the major version when pinning dependencies.
  442. - **Minor**: This level indicates additions of new features or extensions to
  443. existing ones. Typically, these changes do not break existing implementations.
  444. - **Patch**: Here, you'll find bug fixes, documentation updates, and changes
  445. related to continuous integration (CI). These updates are intended to enhance
  446. stability and reliability without altering existing functionality.
  447. Coding standards are not always followed to make arguments and function names as
  448. similar as possible to those of the Kraken API documentations.
  449. <a name="considerations"></a>
  450. # Considerations
  451. The tool aims to be fast, easy to use and maintain. In the past, lots of clients
  452. were implemented, that provided functions for almost all available endpoints of
  453. the Kraken API. The effort to maintain this collection grew to a level where it
  454. was not possible to check various changelogs to apply new updates on a regular
  455. basis. Instead, it was decided to concentrate on the `request` functions of
  456. the `SpotClient`, `SpotAsyncClient`, `FuturesClient` and the
  457. `FuturesAsyncClient` (as well as their websocket client implementations). All
  458. those clients named "User", "Trade", "Market", "Funding" and so on will no
  459. longer be extended, but maintained to a certain degree. The client's `request`
  460. method takes the raw method, URI, and parameters directly, so every endpoint
  461. and parameter documented by Kraken's API is already reachable without a named
  462. wrapper method. Existing wrapper methods still receive bug fixes. Websocket
  463. clients keep gaining new channels and features, since those cannot be reached
  464. through a plain `request` call.
  465. <a name="references"></a>
  466. # 🔭 References
  467. - https://python-kraken-sdk.readthedocs.io/en/stable
  468. - https://docs.kraken.com/api/
  469. - https://docs.kraken.com/api/docs/guides/global-intro
  470. - https://support.kraken.com/hc/en-us/sections/360012894412-Futures-API
  471. ---

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.