bitvavo-api-upgraded 2.0.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

bitvavo_api_upgraded/bitvavo.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 import datetime as dt
 import hashlib
 import hmac
@@ -10,20 +11,27 @@ from threading import Thread
 from typing import Any, Callable
 
 import websocket as ws_lib
+from deprecated import deprecated
 from requests import delete, get, post, put
 from structlog.stdlib import get_logger
 from websocket import WebSocketApp  # missing stubs for WebSocketApp
 
+from bitvavo_api_upgraded.dataframe_utils import convert_candles_to_dataframe, convert_to_dataframe
 from bitvavo_api_upgraded.helper_funcs import configure_loggers, time_ms, time_to_wait
-from bitvavo_api_upgraded.settings import bitvavo_upgraded_settings
-from bitvavo_api_upgraded.type_aliases import anydict, errordict, intdict, ms, s_f, strdict, strintdict
+from bitvavo_api_upgraded.settings import bitvavo_settings, bitvavo_upgraded_settings
+from bitvavo_api_upgraded.type_aliases import OutputFormat, anydict, errordict, intdict, ms, s_f, strdict, strintdict
 
 configure_loggers()
 
 logger = get_logger(__name__)
 
 
+@deprecated(version="2.2.0", reason="Use create_signature instead")
 def createSignature(timestamp: ms, method: str, url: str, body: anydict | None, api_secret: str) -> str:
+    return create_signature(timestamp, method, url, body, api_secret)
+
+
+def create_signature(timestamp: ms, method: str, url: str, body: anydict | None, api_secret: str) -> str:
     string = f"{timestamp}{method}/v2{url}"
     if body is not None and len(body.keys()) > 0:
         string += json.dumps(body, separators=(",", ":"))
@@ -31,7 +39,12 @@ def createSignature(timestamp: ms, method: str, url: str, body: anydict | None,
     return signature
 
 
+@deprecated(version="2.2.0", reason="Use create_postfix instead")
 def createPostfix(options: anydict | None) -> str:
+    return create_postfix(options)
+
+
+def create_postfix(options: anydict | None) -> str:
     """Generate a URL postfix, based on the `options` dict.
 
     ---
@@ -65,18 +78,37 @@ def _epoch_millis(dt: dt.datetime) -> int:
     return int(dt.timestamp() * 1000)
 
 
+@deprecated(version="2.2.0", reason="Use asks_compare instead")
 def asksCompare(a: float, b: float) -> bool:
+    return asks_compare(a, b)
+
+
+def asks_compare(a: float, b: float) -> bool:
     return a < b
 
 
+@deprecated(version="2.2.0", reason="Use bids_compare instead")
 def bidsCompare(a: float, b: float) -> bool:
+    return bids_compare(a, b)
+
+
+def bids_compare(a: float, b: float) -> bool:
     return a > b
 
 
+@deprecated(version="2.2.0", reason="Use sort_and_insert instead")
 def sortAndInsert(
     asks_or_bids: list[list[str]],
     update: list[list[str]],
     compareFunc: Callable[[float, float], bool],
+) -> list[list[str]] | errordict:
+    return sort_and_insert(asks_or_bids, update, compareFunc)
+
+
+def sort_and_insert(
+    asks_or_bids: list[list[str]],
+    update: list[list[str]],
+    compareFunc: Callable[[float, float], bool],
 ) -> list[list[str]] | errordict:
     for updateEntry in update:
         entrySet: bool = False
@@ -99,7 +131,12 @@ def sortAndInsert(
     return asks_or_bids
 
 
+@deprecated(version="2.2.0", reason="Use process_local_book instead")
 def processLocalBook(ws: Bitvavo.WebSocketAppFacade, message: anydict) -> None:
+    return process_local_book(ws, message)
+
+
+def process_local_book(ws: Bitvavo.WebSocketAppFacade, message: anydict) -> None:
     market: str = ""
     if "action" in message:
         if message["action"] == "getBook":
@@ -113,10 +150,10 @@ def processLocalBook(ws: Bitvavo.WebSocketAppFacade, message: anydict) -> None:
 
         if message["nonce"] != ws.localBook[market]["nonce"] + 1:
             # I think I've fixed this, by looking at the other Bitvavo repos (search for 'nonce' or '!=' 😆)
-            ws.subscriptionBook(market, ws.callbacks[market])
+            ws.subscription_book(market, ws.callbacks[market])
             return
-        ws.localBook[market]["bids"] = sortAndInsert(ws.localBook[market]["bids"], message["bids"], bidsCompare)
-        ws.localBook[market]["asks"] = sortAndInsert(ws.localBook[market]["asks"], message["asks"], asksCompare)
+        ws.localBook[market]["bids"] = sort_and_insert(ws.localBook[market]["bids"], message["bids"], bids_compare)
+        ws.localBook[market]["asks"] = sort_and_insert(ws.localBook[market]["asks"], message["asks"], asks_compare)
         ws.localBook[market]["nonce"] = message["nonce"]
 
     if market != "":
@@ -216,6 +253,7 @@ class Bitvavo:
     Example code to get your started:
 
     ```python
+    # Single API key (backward compatible)
     bitvavo = Bitvavo(
         {
             "APIKEY": "$YOUR_API_KEY",
@@ -227,24 +265,204 @@ class Bitvavo:
         },
     )
     time_dict = bitvavo.time()
+
+    # Multiple API keys with keyless preference
+    bitvavo = Bitvavo(
+        {
+            "APIKEYS": [
+                {"key": "$YOUR_API_KEY_1", "secret": "$YOUR_API_SECRET_1"},
+                {"key": "$YOUR_API_KEY_2", "secret": "$YOUR_API_SECRET_2"},
+                {"key": "$YOUR_API_KEY_3", "secret": "$YOUR_API_SECRET_3"},
+            ],
+            "PREFER_KEYLESS": True,  # Use keyless requests first, then API keys
+            "RESTURL": "https://api.bitvavo.com/v2",
+            "WSURL": "wss://ws.bitvavo.com/v2/",
+            "ACCESSWINDOW": 10000,
+            "DEBUGGING": True,
+        },
+    )
+    time_dict = bitvavo.time()
+
+    # Keyless only (no API keys)
+    bitvavo = Bitvavo(
+        {
+            "PREFER_KEYLESS": True,
+            "RESTURL": "https://api.bitvavo.com/v2",
+            "WSURL": "wss://ws.bitvavo.com/v2/",
+            "ACCESSWINDOW": 10000,
+            "DEBUGGING": True,
+        },
+    )
+    markets = bitvavo.markets()  # Only public endpoints will work
     ```
     """
 
-    def __init__(self, options: dict[str, str | int] | None = None) -> None:
+    def __init__(self, options: dict[str, str | int | list[dict[str, str]]] | None = None) -> None:
         if options is None:
             options = {}
         _options = {k.upper(): v for k, v in options.items()}
-        self.base: str = str(_options.get("RESTURL", "https://api.bitvavo.com/v2"))
-        self.wsUrl: str = str(_options.get("WSURL", "wss://ws.bitvavo.com/v2/"))
-        self.ACCESSWINDOW = ms(_options.get("ACCESSWINDOW", 10000))
-        self.APIKEY = str(_options.get("APIKEY", ""))
-        self.APISECRET = str(_options.get("APISECRET", ""))
-        self.rateLimitRemaining: int = 1000
+
+        # Options take precedence over settings
+        self.base: str = str(_options.get("RESTURL", bitvavo_settings.RESTURL))
+        self.wsUrl: str = str(_options.get("WSURL", bitvavo_settings.WSURL))
+        self.ACCESSWINDOW: int = int(_options.get("ACCESSWINDOW", bitvavo_settings.ACCESSWINDOW))
+
+        # Support for multiple API keys - options take absolute precedence
+        if "APIKEY" in _options and "APISECRET" in _options:
+            # Single API key explicitly provided in options - takes precedence
+            single_key = str(_options["APIKEY"])
+            single_secret = str(_options["APISECRET"])
+            self.api_keys: list[dict[str, str]] = [{"key": single_key, "secret": single_secret}]
+        elif "APIKEYS" in _options:
+            # Multiple API keys provided in options - takes precedence
+            api_keys = _options["APIKEYS"]
+            if isinstance(api_keys, list) and api_keys:
+                self.api_keys = api_keys
+            else:
+                self.api_keys = []
+        else:
+            # Fall back to settings only if no API key options provided
+            api_keys = bitvavo_settings.APIKEYS
+            if isinstance(api_keys, list) and api_keys:
+                self.api_keys = api_keys
+            else:
+                # Single API key from settings (backward compatibility)
+                single_key = str(bitvavo_settings.APIKEY)
+                single_secret = str(bitvavo_settings.APISECRET)
+                if single_key and single_secret:
+                    self.api_keys = [{"key": single_key, "secret": single_secret}]
+                else:
+                    self.api_keys = []
+
+        # Current API key index and keyless preference - options take precedence
+        self.current_api_key_index: int = 0
+        self.prefer_keyless: bool = bool(_options.get("PREFER_KEYLESS", bitvavo_upgraded_settings.PREFER_KEYLESS))
+
+        # Rate limiting per API key (keyless has index -1)
+        self.rate_limits: dict[int, dict[str, int | ms]] = {}
+        # Get default rate limit from options or settings
+        default_rate_limit_option = _options.get("DEFAULT_RATE_LIMIT", bitvavo_upgraded_settings.DEFAULT_RATE_LIMIT)
+        default_rate_limit = (
+            int(default_rate_limit_option)
+            if isinstance(default_rate_limit_option, (int, str))
+            else bitvavo_upgraded_settings.DEFAULT_RATE_LIMIT
+        )
+
+        self.rate_limits[-1] = {"remaining": default_rate_limit, "resetAt": ms(0)}  # keyless
+        for i in range(len(self.api_keys)):
+            self.rate_limits[i] = {"remaining": default_rate_limit, "resetAt": ms(0)}
+
+        # Legacy properties for backward compatibility
+        self.APIKEY: str = self.api_keys[0]["key"] if self.api_keys else ""
+        self.APISECRET: str = self.api_keys[0]["secret"] if self.api_keys else ""
+        self._current_api_key: str = self.APIKEY
+        self._current_api_secret: str = self.APISECRET
+        self.rateLimitRemaining: int = default_rate_limit
         self.rateLimitResetAt: ms = 0
-        # TODO(NostraDavid): for v2: remove this functionality - logger.debug is a level that can be set
-        self.debugging = bool(_options.get("DEBUGGING", False))
 
+        # Options take precedence over settings for debugging
+        self.debugging: bool = bool(_options.get("DEBUGGING", bitvavo_settings.DEBUGGING))
+
+    def get_best_api_key_config(self, rateLimitingWeight: int = 1) -> tuple[str, str, int]:
+        """
+        Get the best API key configuration to use for a request.
+
+        Returns:
+            tuple: (api_key, api_secret, key_index) where key_index is -1 for keyless
+        """
+        # If prefer keyless and keyless has enough rate limit, use keyless
+        if self.prefer_keyless and self._has_rate_limit_available(-1, rateLimitingWeight):
+            return "", "", -1
+
+        # Try to find an API key with enough rate limit
+        for i in range(len(self.api_keys)):
+            if self._has_rate_limit_available(i, rateLimitingWeight):
+                return self.api_keys[i]["key"], self.api_keys[i]["secret"], i
+
+        # If keyless is available, use it as fallback
+        if self._has_rate_limit_available(-1, rateLimitingWeight):
+            return "", "", -1
+
+        # No keys available, use current key and let rate limiting handle the wait
+        if self.api_keys:
+            return (
+                self.api_keys[self.current_api_key_index]["key"],
+                self.api_keys[self.current_api_key_index]["secret"],
+                self.current_api_key_index,
+            )
+        return "", "", -1
+
+    def _has_rate_limit_available(self, key_index: int, weight: int) -> bool:
+        """Check if a specific API key (or keyless) has enough rate limit."""
+        if key_index not in self.rate_limits:
+            return False
+        remaining = self.rate_limits[key_index]["remaining"]
+        return (remaining - weight) > bitvavo_upgraded_settings.RATE_LIMITING_BUFFER
+
+    def _update_rate_limit_for_key(self, key_index: int, response: anydict | errordict) -> None:
+        """Update rate limit for a specific API key index."""
+        if key_index not in self.rate_limits:
+            self.rate_limits[key_index] = {"remaining": 1000, "resetAt": ms(0)}
+
+        if "errorCode" in response and response["errorCode"] == 105:  # noqa: PLR2004
+            self.rate_limits[key_index]["remaining"] = 0
+            # rateLimitResetAt is a value that's stripped from a string.
+            reset_time_str = str(response.get("error", "")).split(" at ")
+            if len(reset_time_str) > 1:
+                try:
+                    reset_time = ms(int(reset_time_str[1].split(".")[0]))
+                    self.rate_limits[key_index]["resetAt"] = reset_time
+                except (ValueError, IndexError):
+                    # Fallback to current time + 60 seconds if parsing fails
+                    self.rate_limits[key_index]["resetAt"] = ms(time_ms() + 60000)
+            else:
+                self.rate_limits[key_index]["resetAt"] = ms(time_ms() + 60000)
+
+            timeToWait = time_to_wait(ms(self.rate_limits[key_index]["resetAt"]))
+            key_name = f"API_KEY_{key_index}" if key_index >= 0 else "KEYLESS"
+            logger.warning(
+                "api-key-banned",
+                info={
+                    "key_name": key_name,
+                    "wait_time_seconds": timeToWait + 1,
+                    "until": (dt.datetime.now(tz=dt.timezone.utc) + dt.timedelta(seconds=timeToWait + 1)).isoformat(),
+                },
+            )
+
+        if "bitvavo-ratelimit-remaining" in response:
+            with contextlib.suppress(ValueError, TypeError):
+                self.rate_limits[key_index]["remaining"] = int(response["bitvavo-ratelimit-remaining"])
+
+        if "bitvavo-ratelimit-resetat" in response:
+            with contextlib.suppress(ValueError, TypeError):
+                self.rate_limits[key_index]["resetAt"] = ms(int(response["bitvavo-ratelimit-resetat"]))
+
+    def _sleep_for_key(self, key_index: int) -> None:
+        """Sleep until the specified API key's rate limit resets."""
+        if key_index not in self.rate_limits:
+            return
+
+        reset_at = ms(self.rate_limits[key_index]["resetAt"])
+        napTime = time_to_wait(reset_at)
+        key_name = f"API_KEY_{key_index}" if key_index >= 0 else "KEYLESS"
+
+        logger.warning(
+            "rate-limit-reached", key_name=key_name, rateLimitRemaining=self.rate_limits[key_index]["remaining"]
+        )
+        logger.info(
+            "napping-until-reset",
+            key_name=key_name,
+            napTime=napTime,
+            currentTime=dt.datetime.now(tz=dt.timezone.utc).isoformat(),
+            targetDatetime=dt.datetime.fromtimestamp(reset_at / 1000.0, tz=dt.timezone.utc).isoformat(),
+        )
+        time.sleep(napTime + 1)  # +1 to add a tiny bit of buffer time
+
+    @deprecated(version="2.2.0", reason="Use calc_lag instead")
     def calcLag(self) -> ms:
+        return self.calc_lag()
+
+    def calc_lag(self) -> ms:
         """
         Calculate the time difference between the client and server; use this value with BITVAVO_API_UPGRADED_LAG,
         when you make an api call, to precent 304 errors.
@@ -266,8 +484,12 @@ class Bitvavo:
 
         return ms(sum(lag_list) / len(lag_list))
 
+    @deprecated(version="2.2.0", reason="Use get_remaining_limit instead")
     def getRemainingLimit(self) -> int:
-        """Get the remaing rate limit
+        return self.get_remaining_limit()
+
+    def get_remaining_limit(self) -> int:
+        """Get the remaining rate limit
 
         ---
         Returns:
@@ -277,21 +499,31 @@ class Bitvavo:
         """
         return self.rateLimitRemaining
 
+    @deprecated(version="2.2.0", reason="Use get_remaining_limit instead")
     def updateRateLimit(self, response: anydict | errordict) -> None:
+        return self.update_rate_limit(response)
+
+    def update_rate_limit(self, response: anydict | errordict) -> None:
         """
         Update the rate limited
 
         If you're banned, use the errordict to sleep until you're not banned
 
         If you're not banned, then use the received headers to update the variables.
+
+        This method maintains backward compatibility by updating the legacy properties.
         """
+        # Update rate limit for the current API key being used
+        current_key = self.current_api_key_index if self.APIKEY else -1
+        self._update_rate_limit_for_key(current_key, response)
+
+        # Update legacy properties for backward compatibility
+        if current_key in self.rate_limits:
+            self.rateLimitRemaining = int(self.rate_limits[current_key]["remaining"])
+            self.rateLimitResetAt = ms(self.rate_limits[current_key]["resetAt"])
+
+        # Handle ban with sleep (legacy behavior)
         if "errorCode" in response and response["errorCode"] == 105:  # noqa: PLR2004
-            self.rateLimitRemaining = 0
-            # rateLimitResetAt is a value that's stripped from a string.
-            # Kind of a terrible way to pass that information, but eh, whatever, I guess...
-            # Anyway, here is the string that's being pulled apart:
-            # "Your IP or API key has been banned for not respecting the rate limit. The ban expires at ${expiryInMs}""
-            self.rateLimitResetAt = ms(response["error"].split(" at ")[1].split(".")[0])
             timeToWait = time_to_wait(self.rateLimitResetAt)
             logger.warning(
                 "banned",
@@ -302,15 +534,19 @@ class Bitvavo:
             )
             logger.info("napping-until-ban-lifted")
             time.sleep(timeToWait + 1)  # plus one second to ENSURE we're able to run again.
-        if "bitvavo-ratelimit-remaining" in response:
-            self.rateLimitRemaining = int(response["bitvavo-ratelimit-remaining"])
-        if "bitvavo-ratelimit-resetat" in response:
-            self.rateLimitResetAt = int(response["bitvavo-ratelimit-resetat"])
 
+    @deprecated(version="2.2.0", reason="Use public_request instead")
     def publicRequest(
         self,
         url: str,
         rateLimitingWeight: int = 1,
+    ) -> list[anydict] | list[list[str]] | intdict | strdict | anydict | errordict:
+        return self.public_request(url, rateLimitingWeight)
+
+    def public_request(
+        self,
+        url: str,
+        rateLimitingWeight: int = 1,
     ) -> list[anydict] | list[list[str]] | intdict | strdict | anydict | errordict:
         """Execute a request to the public part of the API; no API key and/or SECRET necessary.
         Will return the reponse as one of three types.
@@ -330,22 +566,39 @@ class Bitvavo:
         list[list[str]]
         ```
         """
-        if (self.rateLimitRemaining - rateLimitingWeight) <= bitvavo_upgraded_settings.RATE_LIMITING_BUFFER:
-            self.sleep_until_can_continue()
+        # Get the best API key configuration (keyless preferred, then available keys)
+        api_key, api_secret, key_index = self.get_best_api_key_config(rateLimitingWeight)
+
+        # Check if we need to wait for rate limit
+        if not self._has_rate_limit_available(key_index, rateLimitingWeight):
+            self._sleep_for_key(key_index)
+
+        # Update current API key for legacy compatibility
+        if api_key:
+            self._current_api_key = api_key
+            self._current_api_secret = api_secret
+            self.current_api_key_index = key_index
+        else:
+            # Using keyless
+            self._current_api_key = ""
+            self._current_api_secret = ""
+
         if self.debugging:
             logger.debug(
                 "api-request",
                 info={
                     "url": url,
-                    "with_api_key": bool(self.APIKEY != ""),
+                    "with_api_key": bool(api_key != ""),
                     "public_or_private": "public",
+                    "key_index": key_index,
                 },
             )
-        if self.APIKEY != "":
+
+        if api_key:
             now = time_ms() + bitvavo_upgraded_settings.LAG
-            sig = createSignature(now, "GET", url.replace(self.base, ""), None, self.APISECRET)
+            sig = create_signature(now, "GET", url.replace(self.base, ""), None, api_secret)
             headers = {
-                "bitvavo-access-key": self.APIKEY,
+                "bitvavo-access-key": api_key,
                 "bitvavo-access-signature": sig,
                 "bitvavo-access-timestamp": str(now),
                 "bitvavo-access-window": str(self.ACCESSWINDOW),
@@ -353,12 +606,19 @@ class Bitvavo:
             r = get(url, headers=headers, timeout=(self.ACCESSWINDOW / 1000))
         else:
             r = get(url, timeout=(self.ACCESSWINDOW / 1000))
+
+        # Update rate limit for the specific key used
         if "error" in r.json():
-            self.updateRateLimit(r.json())
+            self._update_rate_limit_for_key(key_index, r.json())
         else:
-            self.updateRateLimit(dict(r.headers))
+            self._update_rate_limit_for_key(key_index, dict(r.headers))
+
+        # Also update legacy rate limit tracking
+        self.update_rate_limit(r.json() if "error" in r.json() else dict(r.headers))
+
         return r.json()  # type:ignore[no-any-return]
 
+    @deprecated(version="2.2.0", reason="Use private_request instead")
     def privateRequest(
         self,
         endpoint: str,
@@ -366,7 +626,17 @@ class Bitvavo:
         body: anydict | None = None,
         method: str = "GET",
         rateLimitingWeight: int = 1,
-    ) -> list[anydict] | list[list[str]] | intdict | strdict | anydict | Any | errordict:
+    ) -> list[anydict] | list[list[str]] | intdict | strdict | anydict | errordict:
+        return self.private_request(endpoint, postfix, body, method, rateLimitingWeight)
+
+    def private_request(
+        self,
+        endpoint: str,
+        postfix: str,
+        body: anydict | None = None,
+        method: str = "GET",
+        rateLimitingWeight: int = 1,
+    ) -> list[anydict] | list[list[str]] | intdict | strdict | anydict | errordict:
         """Execute a request to the private  part of the API. API key and SECRET are required.
         Will return the reponse as one of three types.
 
@@ -389,14 +659,33 @@ class Bitvavo:
         list[list[str]]
         ```
         """
-        if (self.rateLimitRemaining - rateLimitingWeight) <= bitvavo_upgraded_settings.RATE_LIMITING_BUFFER:
-            self.sleep_until_can_continue()
-        # if this method breaks: add `= {}` after `body: dict`
+        # Private requests require an API key, so get the best available one
+        api_key, api_secret, key_index = self.get_best_api_key_config(rateLimitingWeight)
+
+        # If no API keys available, use the configured one (may fail)
+        if not api_key and self.api_keys:
+            api_key = self.api_keys[self.current_api_key_index]["key"]
+            api_secret = self.api_keys[self.current_api_key_index]["secret"]
+            key_index = self.current_api_key_index
+        elif not api_key:
+            # No API keys configured at all
+            api_key = self.APIKEY
+            api_secret = self.APISECRET
+            key_index = 0 if api_key else -1
+
+        # Check if we need to wait for rate limit
+        if not self._has_rate_limit_available(key_index, rateLimitingWeight):
+            self._sleep_for_key(key_index)
+
+        # Update current API key for legacy compatibility
+        self._current_api_key = api_key
+        self._current_api_secret = api_secret
+
         now = time_ms() + bitvavo_upgraded_settings.LAG
-        sig = createSignature(now, method, (endpoint + postfix), body, self.APISECRET)
+        sig = create_signature(now, method, (endpoint + postfix), body, api_secret)
         url = self.base + endpoint + postfix
         headers = {
-            "bitvavo-access-key": self.APIKEY,
+            "bitvavo-access-key": api_key,
             "bitvavo-access-signature": sig,
             "bitvavo-access-timestamp": str(now),
             "bitvavo-access-window": str(self.ACCESSWINDOW),
@@ -406,9 +695,10 @@ class Bitvavo:
                 "api-request",
                 info={
                     "url": url,
-                    "with_api_key": bool(self.APIKEY != ""),
+                    "with_api_key": bool(api_key != ""),
                     "public_or_private": "private",
                     "method": method,
+                    "key_index": key_index,
                 },
             )
         if method == "DELETE":
@@ -419,10 +709,16 @@ class Bitvavo:
             r = put(url, headers=headers, json=body, timeout=(self.ACCESSWINDOW / 1000))
         else:  # method == "GET"
             r = get(url, headers=headers, timeout=(self.ACCESSWINDOW / 1000))
+
+        # Update rate limit for the specific key used
         if "error" in r.json():
-            self.updateRateLimit(r.json())
+            self._update_rate_limit_for_key(key_index, r.json())
         else:
-            self.updateRateLimit(dict(r.headers))
+            self._update_rate_limit_for_key(key_index, dict(r.headers))
+
+        # Also update legacy rate limit tracking
+        self.update_rate_limit(r.json() if "error" in r.json() else dict(r.headers))
+
         return r.json()
 
     def sleep_until_can_continue(self) -> None:
@@ -455,9 +751,13 @@ class Bitvavo:
         {"time": 1539180275424 }
         ```
         """
-        return self.publicRequest(f"{self.base}/time")  # type: ignore[return-value]
+        return self.public_request(f"{self.base}/time")  # type: ignore[return-value]
 
-    def markets(self, options: strdict | None = None) -> list[anydict] | anydict | errordict:
+    def markets(
+        self,
+        options: strdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[anydict] | anydict | errordict | Any:
         """Get all available markets with some meta-information, unless options is given a `market` key.
         Then you will get a single market, instead of a list of markets.
 
@@ -474,6 +774,23 @@ class Bitvavo:
         options={}  # returns all markets
         options={"market": "BTC-EUR"}  # returns only the BTC-EUR market
         # If you want multiple markets, but not all, make multiple calls
+
+        # Output format selection:
+        output_format=OutputFormat.DICT      # Default: returns standard Python dict/list
+        output_format=OutputFormat.PANDAS    # Returns pandas DataFrame
+        output_format=OutputFormat.POLARS    # Returns polars DataFrame
+        output_format=OutputFormat.CUDF      # Returns NVIDIA cuDF (GPU-accelerated)
+        output_format=OutputFormat.MODIN     # Returns modin (distributed pandas)
+        output_format=OutputFormat.PYARROW   # Returns Apache Arrow Table
+        output_format=OutputFormat.DASK      # Returns Dask DataFrame (distributed)
+        output_format=OutputFormat.DUCKDB    # Returns DuckDB relation
+        output_format=OutputFormat.IBIS      # Returns Ibis expression
+        output_format=OutputFormat.PYSPARK   # Returns PySpark DataFrame
+        output_format=OutputFormat.PYSPARK_CONNECT  # Returns PySpark Connect DataFrame
+        output_format=OutputFormat.SQLFRAME  # Returns SQLFrame DataFrame
+
+        # Note: DataFrame formats require narwhals and the respective library to be installed.
+        # Install with: pip install 'bitvavo-api-upgraded[pandas]' or similar for other formats.
         ```
 
         ---
@@ -485,6 +802,7 @@ class Bitvavo:
         ---
         Returns:
         ```python
+        # When output_format=OutputFormat.DICT (default):
         [
           {
             "market": "BTC-EUR",
@@ -504,12 +822,22 @@ class Bitvavo:
             ]
           }
         ]
+
+        # When output_format is any DataFrame format (pandas, polars, cudf, etc.):
+        # Returns a DataFrame with columns: market, status, base, quote, pricePrecision,
+        # minOrderInQuoteAsset, minOrderInBaseAsset, orderTypes
+        # The specific DataFrame type depends on the selected format.
         ```
         """
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/markets{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/markets{postfix}")  # type: ignore[return-value]
+        return convert_to_dataframe(result, output_format)
 
-    def assets(self, options: strdict | None = None) -> list[anydict] | anydict:
+    def assets(
+        self,
+        options: strdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[anydict] | anydict | Any:
         """Get all available assets, unless `options` is given a `symbol` key.
         Then you will get a single asset, instead of a list of assets.
 
@@ -527,6 +855,23 @@ class Bitvavo:
         # pick one
         options={}  # returns all assets
         options={"symbol": "BTC"} # returns a single asset (the one of Bitcoin)
+
+        # Output format selection:
+        output_format=OutputFormat.DICT      # Default: returns standard Python dict/list
+        output_format=OutputFormat.PANDAS    # Returns pandas DataFrame
+        output_format=OutputFormat.POLARS    # Returns polars DataFrame
+        output_format=OutputFormat.CUDF      # Returns NVIDIA cuDF (GPU-accelerated)
+        output_format=OutputFormat.MODIN     # Returns modin (distributed pandas)
+        output_format=OutputFormat.PYARROW   # Returns Apache Arrow Table
+        output_format=OutputFormat.DASK      # Returns Dask DataFrame (distributed)
+        output_format=OutputFormat.DUCKDB    # Returns DuckDB relation
+        output_format=OutputFormat.IBIS      # Returns Ibis expression
+        output_format=OutputFormat.PYSPARK   # Returns PySpark DataFrame
+        output_format=OutputFormat.PYSPARK_CONNECT  # Returns PySpark Connect DataFrame
+        output_format=OutputFormat.SQLFRAME  # Returns SQLFrame DataFrame
+
+        # Note: DataFrame formats require narwhals and the respective library to be installed.
+        # Install with: pip install 'bitvavo-api-upgraded[pandas]' or similar for other formats.
         ```
 
         ---
@@ -538,6 +883,7 @@ class Bitvavo:
         ---
         Returns:
         ```python
+        # When output_format=OutputFormat.DICT (default):
         [
           {
             "symbol": "BTC",
@@ -553,10 +899,17 @@ class Bitvavo:
             "message": ""
           }
         ]
+
+        # When output_format is any DataFrame format (pandas, polars, cudf, etc.):
+        # Returns a DataFrame with columns: symbol, name, decimals, depositFee,
+        # depositConfirmations, depositStatus, withdrawalFee, withdrawalMinAmount,
+        # withdrawalStatus, networks, message
+        # The specific DataFrame type depends on the selected format.
         ```
         """
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/assets{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/assets{postfix}")  # type: ignore[return-value]
+        return convert_to_dataframe(result, output_format)
 
     def book(self, market: str, options: intdict | None = None) -> dict[str, str | int | list[str]] | errordict:
         """Get a book (with two lists: asks and bids, as they're called)
@@ -600,10 +953,24 @@ class Bitvavo:
         assert result == 714.48  # EUR can be gained from this bid if it's sold (minus the fee)
         ```
         """
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/{market}/book{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.public_request(f"{self.base}/{market}/book{postfix}")  # type: ignore[return-value]
+
+    @deprecated(version="2.2.0", reason="Use public_trades instead")
+    def publicTrades(
+        self,
+        market: str,
+        options: strintdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[anydict] | errordict | Any:
+        return self.public_trades(market, options, output_format)
 
-    def publicTrades(self, market: str, options: strintdict | None = None) -> list[anydict] | errordict:
+    def public_trades(
+        self,
+        market: str,
+        options: strintdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[anydict] | errordict | Any:
         """Publically available trades
 
         ---
@@ -628,6 +995,23 @@ class Bitvavo:
             "tradeIdFrom": ""  # if you get a list and want everything AFTER a certain id, put that id here
             "tradeIdTo": ""  # if you get a list and want everything BEFORE a certain id, put that id here
         }
+
+        # Output format selection:
+        output_format=OutputFormat.DICT      # Default: returns standard Python dict/list
+        output_format=OutputFormat.PANDAS    # Returns pandas DataFrame
+        output_format=OutputFormat.POLARS    # Returns polars DataFrame
+        output_format=OutputFormat.CUDF      # Returns NVIDIA cuDF (GPU-accelerated)
+        output_format=OutputFormat.MODIN     # Returns modin (distributed pandas)
+        output_format=OutputFormat.PYARROW   # Returns Apache Arrow Table
+        output_format=OutputFormat.DASK      # Returns Dask DataFrame (distributed)
+        output_format=OutputFormat.DUCKDB    # Returns DuckDB relation
+        output_format=OutputFormat.IBIS      # Returns Ibis expression
+        output_format=OutputFormat.PYSPARK   # Returns PySpark DataFrame
+        output_format=OutputFormat.PYSPARK_CONNECT  # Returns PySpark Connect DataFrame
+        output_format=OutputFormat.SQLFRAME  # Returns SQLFrame DataFrame
+
+        # Note: DataFrame formats require narwhals and the respective library to be installed.
+        # Install with: pip install 'bitvavo-api-upgraded[pandas]' or similar for other formats.
         ```
 
         ---
@@ -639,6 +1023,7 @@ class Bitvavo:
         ---
         Returns:
         ```python
+        # When output_format='dict' (default):
         [
           {
             "timestamp": 1542967486256,
@@ -648,10 +1033,14 @@ class Bitvavo:
             "side": "sell"
           }
         ]
+
+        # When output_format is any DataFrame format:
+        # Returns the above data as a DataFrame in the requested format (pandas, polars, etc.)
         ```
         """
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/{market}/trades{postfix}", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/{market}/trades{postfix}", 5)  # type: ignore[return-value]
+        return convert_to_dataframe(result, output_format)
 
     def candles(
         self,
@@ -661,7 +1050,8 @@ class Bitvavo:
         limit: int | None = None,
         start: dt.datetime | None = None,
         end: dt.datetime | None = None,
-    ) -> list[list[str]] | errordict:
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[list[str]] | errordict | Any:
         """Get up to 1440 candles for a market, with a specific interval (candle size)
 
         Extra reading material: https://en.wikipedia.org/wiki/Candlestick_chart
@@ -684,6 +1074,23 @@ class Bitvavo:
             "start": int timestamp in ms >= 0
             "end": int timestamp in ms <= 8640000000000000
         }
+
+        # Output format selection:
+        output_format=OutputFormat.DICT      # Default: returns standard Python list/dict
+        output_format=OutputFormat.PANDAS    # Returns pandas DataFrame
+        output_format=OutputFormat.POLARS    # Returns polars DataFrame
+        output_format=OutputFormat.CUDF      # Returns NVIDIA cuDF (GPU-accelerated)
+        output_format=OutputFormat.MODIN     # Returns modin (distributed pandas)
+        output_format=OutputFormat.PYARROW   # Returns Apache Arrow Table
+        output_format=OutputFormat.DASK      # Returns Dask DataFrame (distributed)
+        output_format=OutputFormat.DUCKDB    # Returns DuckDB relation
+        output_format=OutputFormat.IBIS      # Returns Ibis expression
+        output_format=OutputFormat.PYSPARK   # Returns PySpark DataFrame
+        output_format=OutputFormat.PYSPARK_CONNECT  # Returns PySpark Connect DataFrame
+        output_format=OutputFormat.SQLFRAME  # Returns SQLFrame DataFrame
+
+        # Note: DataFrame formats require narwhals and the respective library to be installed.
+        # Install with: pip install 'bitvavo-api-upgraded[pandas]' or similar for other formats.
         ```
 
         ---
@@ -695,6 +1102,7 @@ class Bitvavo:
         ---
         Returns:
         ```python
+        # When output_format='dict' (default):
         [
           # For whatever reason, you're getting a list of lists; no keys,
           # so here is the explanation of what's what.
@@ -705,6 +1113,11 @@ class Bitvavo:
           [1640804400000, "41937", "41955", "41449", "41540", "23.64498292"],
           [1640800800000, "41955", "42163", "41807", "41939", "10.40093845"],
         ]
+
+        # When output_format is any DataFrame format:
+        # Returns the above data as a DataFrame in the requested format (pandas, polars, etc.)
+        # with columns: timestamp, open, high, low, close, volume
+        # timestamp is converted to datetime, numeric columns to float
         ```
         """
         options = _default(options, {})
@@ -715,10 +1128,23 @@ class Bitvavo:
             options["start"] = _epoch_millis(start)
         if end is not None:
             options["end"] = _epoch_millis(end)
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/{market}/candles{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/{market}/candles{postfix}")  # type: ignore[return-value]
+        return convert_candles_to_dataframe(result, output_format)
+
+    @deprecated(version="2.2.0", reason="Use ticker_price instead")
+    def tickerPrice(
+        self,
+        options: strdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[strdict] | strdict | Any:
+        return self.ticker_price(options, output_format)
 
-    def tickerPrice(self, options: strdict | None = None) -> list[strdict] | strdict:
+    def ticker_price(
+        self,
+        options: strdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[strdict] | strdict | Any:
         """Get the current price for each market
 
         ---
@@ -735,6 +1161,23 @@ class Bitvavo:
         ```python
         options={}
         options={"market": "BTC-EUR"}
+
+        # Output format selection:
+        output_format=OutputFormat.DICT      # Default: returns standard Python dict/list
+        output_format=OutputFormat.PANDAS    # Returns pandas DataFrame
+        output_format=OutputFormat.POLARS    # Returns polars DataFrame
+        output_format=OutputFormat.CUDF      # Returns NVIDIA cuDF (GPU-accelerated)
+        output_format=OutputFormat.MODIN     # Returns modin (distributed pandas)
+        output_format=OutputFormat.PYARROW   # Returns Apache Arrow Table
+        output_format=OutputFormat.DASK      # Returns Dask DataFrame (distributed)
+        output_format=OutputFormat.DUCKDB    # Returns DuckDB relation
+        output_format=OutputFormat.IBIS      # Returns Ibis expression
+        output_format=OutputFormat.PYSPARK   # Returns PySpark DataFrame
+        output_format=OutputFormat.PYSPARK_CONNECT  # Returns PySpark Connect DataFrame
+        output_format=OutputFormat.SQLFRAME  # Returns SQLFrame DataFrame
+
+        # Note: DataFrame formats require narwhals and the respective library to be installed.
+        # Install with: pip install 'bitvavo-api-upgraded[pandas]' or similar for other formats.
         ```
 
         ---
@@ -746,6 +1189,7 @@ class Bitvavo:
         ---
         Returns:
         ```python
+        # When output_format=OutputFormat.DICT (default):
         # Note that `price` is unconverted
         [
           {"market": "1INCH-EUR", "price": "2.1594"},
@@ -761,12 +1205,28 @@ class Bitvavo:
           {"market": "ALGO-EUR", "price": "1.3942"},
           # and another 210 markets below this point
         ]
+
+        # When output_format is any DataFrame format (pandas, polars, cudf, etc.):
+        # Returns a DataFrame with columns: market, price
         ```
         """
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/ticker/price{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/ticker/price{postfix}")  # type: ignore[return-value]
+        return convert_to_dataframe(result, output_format)
+
+    @deprecated(version="2.2.0", reason="Use ticker_book instead")
+    def tickerBook(
+        self,
+        options: strdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[strdict] | strdict | Any:
+        return self.ticker_book(options, output_format)
 
-    def tickerBook(self, options: strdict | None = None) -> list[strdict] | strdict:
+    def ticker_book(
+        self,
+        options: strdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[strdict] | strdict | Any:
         """Get current bid/ask, bidsize/asksize per market
 
         ---
@@ -783,6 +1243,23 @@ class Bitvavo:
         ```python
         options={}
         options={"market": "BTC-EUR"}
+
+        # Output format selection:
+        output_format=OutputFormat.DICT      # Default: returns standard Python dict/list
+        output_format=OutputFormat.PANDAS    # Returns pandas DataFrame
+        output_format=OutputFormat.POLARS    # Returns polars DataFrame
+        output_format=OutputFormat.CUDF      # Returns NVIDIA cuDF (GPU-accelerated)
+        output_format=OutputFormat.MODIN     # Returns modin (distributed pandas)
+        output_format=OutputFormat.PYARROW   # Returns Apache Arrow Table
+        output_format=OutputFormat.DASK      # Returns Dask DataFrame (distributed)
+        output_format=OutputFormat.DUCKDB    # Returns DuckDB relation
+        output_format=OutputFormat.IBIS      # Returns Ibis expression
+        output_format=OutputFormat.PYSPARK   # Returns PySpark DataFrame
+        output_format=OutputFormat.PYSPARK_CONNECT  # Returns PySpark Connect DataFrame
+        output_format=OutputFormat.SQLFRAME  # Returns SQLFrame DataFrame
+
+        # Note: DataFrame formats require narwhals and the respective library to be installed.
+        # Install with: pip install 'bitvavo-api-upgraded[pandas]' or similar for other formats.
         ```
 
         ---
@@ -794,6 +1271,7 @@ class Bitvavo:
         ---
         Returns:
         ```python
+        # When output_format=OutputFormat.DICT (default):
         [
           {"market": "1INCH-EUR", "bid": "2.1534", "ask": "2.1587", "bidSize": "194.8", "askSize": "194.8"},
           {"market": "AAVE-EUR", "bid": "213.7", "ask": "214.05", "bidSize": "212.532", "askSize": "4.77676965"},
@@ -802,12 +1280,20 @@ class Bitvavo:
           {"market": "AION-EUR", "bid": "0.12531", "ask": "0.12578", "bidSize": "3345", "askSize": "10958.49228653"},
           # and another 215 markets below this point
         ]
+
+        # When output_format is any DataFrame format (pandas, polars, cudf, etc.):
+        # Returns a DataFrame with columns: market, bid, ask, bidSize, askSize
         ```
         """
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/ticker/book{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/ticker/book{postfix}")  # type: ignore[return-value]
+        return convert_to_dataframe(result, output_format)
 
-    def ticker24h(self, options: strdict | None = None) -> list[anydict] | anydict | errordict:
+    def ticker24h(
+        self,
+        options: strdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[anydict] | anydict | errordict | Any:
         """Get current bid/ask, bidsize/asksize per market
 
         ---
@@ -824,15 +1310,30 @@ class Bitvavo:
         ```python
         options={}
         options={"market": "BTC-EUR"}
-        ```
 
+        # Output format selection:
+        output_format=OutputFormat.DICT      # Default: returns standard Python dict/list
+        output_format=OutputFormat.PANDAS    # Returns pandas DataFrame
+        output_format=OutputFormat.POLARS    # Returns polars DataFrame
+        output_format=OutputFormat.CUDF      # Returns NVIDIA cuDF (GPU-accelerated)
+        output_format=OutputFormat.MODIN     # Returns modin (distributed pandas)
+        output_format=OutputFormat.PYARROW   # Returns Apache Arrow Table
+        output_format=OutputFormat.DASK      # Returns Dask DataFrame (distributed)
+        output_format=OutputFormat.DUCKDB    # Returns DuckDB relation
+        output_format=OutputFormat.IBIS      # Returns Ibis expression
+        output_format=OutputFormat.PYSPARK   # Returns PySpark DataFrame
+        output_format=OutputFormat.PYSPARK_CONNECT  # Returns PySpark Connect DataFrame
+        output_format=OutputFormat.SQLFRAME  # Returns SQLFrame DataFrame
+
+        # Note: DataFrame formats require narwhals and the respective library to be installed.
+        # Install with: pip install 'bitvavo-api-upgraded[pandas]' or similar for other formats.
+        ```
         ---
         Rate Limit Weight:
         ```python
         25  # if no market option is used
         1  # if a market option is used
         ```
-
         ---
         Returns:
         ```python
@@ -873,10 +1374,25 @@ class Bitvavo:
         rateLimitingWeight = 25
         if "market" in options:
             rateLimitingWeight = 1
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/ticker/24h{postfix}", rateLimitingWeight)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/ticker/24h{postfix}", rateLimitingWeight)  # type: ignore[return-value]
+        return convert_to_dataframe(result, output_format)
+
+    @deprecated(version="2.2.0", reason="Use report_trades instead")
+    def reportTrades(
+        self,
+        market: str,
+        options: strintdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[anydict] | errordict | Any:
+        return self.report_trades(market, options, output_format)
 
-    def reportTrades(self, market: str, options: strintdict | None = None) -> list[anydict] | errordict:
+    def report_trades(
+        self,
+        market: str,
+        options: strintdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[anydict] | errordict | Any:
         """Get MiCA-compliant trades report for a specific market
 
         Returns trades from the specified market and time period made by all Bitvavo users.
@@ -893,14 +1409,27 @@ class Bitvavo:
         ```python
         market="BTC-EUR"
         options={
-            "limit": [ 1 .. 1000 ], default 500
-            "start": int timestamp in ms >= 0
-            "end": int timestamp in ms <= 8_640_000_000_000_000  # Cannot be more than 24 hours after start
-            "tradeIdFrom": ""  # if you get a list and want everything AFTER a certain id, put that id here
-            "tradeIdTo": ""  # if you get a list and want everything BEFORE a certain id, put that id here
+          "limit": [ 1 .. 1000 ], default 500
+          "start": int timestamp in ms >= 0
+          "end": int timestamp in ms <= 8_640_000_000_000_000  # Cannot be more than 24 hours after start
+          "tradeIdFrom": ""  # if you get a list and want everything AFTER a certain id, put that id here
+          "tradeIdTo": ""  # if you get a list and want everything BEFORE a certain id, put that id here
         }
-        ```
 
+        # Output format selection:
+        output_format=OutputFormat.DICT      # Default: returns standard Python dict/list
+        output_format=OutputFormat.PANDAS    # Returns pandas DataFrame
+        output_format=OutputFormat.POLARS    # Returns polars DataFrame
+        output_format=OutputFormat.CUDF      # Returns NVIDIA cuDF (GPU-accelerated)
+        output_format=OutputFormat.MODIN     # Returns modin (distributed pandas)
+        output_format=OutputFormat.PYARROW   # Returns Apache Arrow Table
+        output_format=OutputFormat.DASK      # Returns Dask DataFrame (distributed)
+        output_format=OutputFormat.DUCKDB    # Returns DuckDB relation
+        output_format=OutputFormat.IBIS      # Returns Ibis expression
+        output_format=OutputFormat.PYSPARK   # Returns PySpark DataFrame
+        output_format=OutputFormat.PYSPARK_CONNECT  # Returns PySpark Connect DataFrame
+        output_format=OutputFormat.SQLFRAME  # Returns SQLFrame DataFrame
+        ```
         ---
         Rate Limit Weight:
         ```python
@@ -912,19 +1441,24 @@ class Bitvavo:
         ```python
         [
           {
-            "timestamp": 1542967486256,
-            "id": "57b1159b-6bf5-4cde-9e2c-6bd6a5678baf",
-            "amount": "0.1",
-            "price": "5012",
-            "side": "sell"
+          "timestamp": 1542967486256,
+          "id": "57b1159b-6bf5-4cde-9e2c-6bd6a5678baf",
+          "amount": "0.1",
+          "price": "5012",
+          "side": "sell"
           }
         ]
         ```
         """
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/report/{market}/trades{postfix}", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/report/{market}/trades{postfix}", 5)  # type: ignore[return-value]
+        return convert_to_dataframe(result, output_format)
 
+    @deprecated(version="2.2.0", reason="Use report_book instead")
     def reportBook(self, market: str, options: intdict | None = None) -> dict[str, str | int | list[str]] | errordict:
+        return self.report_book(market, options)
+
+    def report_book(self, market: str, options: intdict | None = None) -> dict[str, str | int | list[str]] | errordict:
         """Get MiCA-compliant order book report for a specific market
 
         Returns the list of all bids and asks for the specified market, sorted by price.
@@ -961,10 +1495,14 @@ class Bitvavo:
         }
         ```
         """
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/report/{market}/book{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.public_request(f"{self.base}/report/{market}/book{postfix}")  # type: ignore[return-value]
 
+    @deprecated(version="2.2.0", reason="Use place_order instead")
     def placeOrder(self, market: str, side: str, orderType: str, operatorId: int, body: anydict) -> anydict:
+        return self.place_order(market, side, orderType, operatorId, body)
+
+    def place_order(self, market: str, side: str, orderType: str, operatorId: int, body: anydict) -> anydict:
         """Place a new order on the exchange
 
         ---
@@ -1093,9 +1631,13 @@ class Bitvavo:
         body["side"] = side
         body["orderType"] = orderType
         body["operatorId"] = operatorId
-        return self.privateRequest("/order", "", body, "POST")  # type: ignore[return-value]
+        return self.private_request("/order", "", body, "POST")  # type: ignore[return-value]
 
+    @deprecated(version="2.2.0", reason="Use update_order instead")
     def updateOrder(self, market: str, orderId: str, operatorId: int, body: anydict) -> anydict:
+        return self.update_order(market, orderId, operatorId, body)
+
+    def update_order(self, market: str, orderId: str, operatorId: int, body: anydict) -> anydict:
         """Update an existing order for a specific market. Make sure that at least one of the optional parameters is set, otherwise nothing will be updated.
 
         ---
@@ -1179,14 +1721,24 @@ class Bitvavo:
         body["market"] = market
         body["orderId"] = orderId
         body["operatorId"] = operatorId
-        return self.privateRequest("/order", "", body, "PUT")  # type: ignore[return-value]
+        return self.private_request("/order", "", body, "PUT")  # type: ignore[return-value]
 
+    @deprecated(version="2.2.0", reason="Use cancel_order instead")
     def cancelOrder(
         self,
         market: str,
         operatorId: int,
         orderId: str | None = None,
         clientOrderId: str | None = None,
+    ) -> strdict:
+        return self.cancel_order(market, operatorId, orderId, clientOrderId)
+
+    def cancel_order(
+        self,
+        market: str,
+        operatorId: int,
+        orderId: str | None = None,
+        clientOrderId: str | None = None,
     ) -> strdict:
         """Cancel an existing order for a specific market
 
@@ -1227,10 +1779,14 @@ class Bitvavo:
         elif orderId is not None:
             params["orderId"] = orderId
 
-        postfix = createPostfix(params)
-        return self.privateRequest("/order", postfix, {}, "DELETE")  # type: ignore[return-value]
+        postfix = create_postfix(params)
+        return self.private_request("/order", postfix, {}, "DELETE")  # type: ignore[return-value]
 
+    @deprecated(version="2.2.0", reason="Use get_order instead")
     def getOrder(self, market: str, orderId: str) -> list[anydict] | errordict:
+        return self.get_order(market, orderId)
+
+    def get_order(self, market: str, orderId: str) -> list[anydict] | errordict:
         """Get an existing order for a specific market
 
         ---
@@ -1292,10 +1848,14 @@ class Bitvavo:
         }
         ```
         """
-        postfix = createPostfix({"market": market, "orderId": orderId})
-        return self.privateRequest("/order", postfix, {}, "GET")  # type: ignore[return-value]
+        postfix = create_postfix({"market": market, "orderId": orderId})
+        return self.private_request("/order", postfix, {}, "GET")  # type: ignore[return-value]
 
+    @deprecated(version="2.2.0", reason="Use get_orders instead")
     def getOrders(self, market: str, options: anydict | None = None) -> list[anydict] | errordict:
+        return self.get_orders(market, options)
+
+    def get_orders(self, market: str, options: anydict | None = None) -> list[anydict] | errordict:
         """Get multiple existing orders for a specific market
 
         ---
@@ -1368,10 +1928,14 @@ class Bitvavo:
         """  # noqa: E501
         options = _default(options, {})
         options["market"] = market
-        postfix = createPostfix(options)
-        return self.privateRequest("/orders", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/orders", postfix, {}, "GET", 5)  # type: ignore[return-value]
 
+    @deprecated(version="2.2.0", reason="Use cancel_orders instead")
     def cancelOrders(self, options: anydict | None = None) -> list[strdict] | errordict:
+        return self.cancel_orders(options)
+
+    def cancel_orders(self, options: anydict | None = None) -> list[strdict] | errordict:
         """Cancel all existing orders for a specific market (or account)
 
         ---
@@ -1396,10 +1960,14 @@ class Bitvavo:
         ]
         ```
         """
-        postfix = createPostfix(options)
-        return self.privateRequest("/orders", postfix, {}, "DELETE")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/orders", postfix, {}, "DELETE")  # type: ignore[return-value]
 
+    @deprecated(version="2.2.0", reason="Use orders_open instead")
     def ordersOpen(self, options: anydict | None = None) -> list[anydict] | errordict:
+        return self.orders_open(options)
+
+    def orders_open(self, options: anydict | None = None) -> list[anydict] | errordict:
         """Get all open orders, either for all markets, or a single market
 
         ---
@@ -1468,10 +2036,15 @@ class Bitvavo:
         rateLimitingWeight = 25
         if "market" in options:
             rateLimitingWeight = 1
-        postfix = createPostfix(options)
-        return self.privateRequest("/ordersOpen", postfix, {}, "GET", rateLimitingWeight)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/ordersOpen", postfix, {}, "GET", rateLimitingWeight)  # type: ignore[return-value]
 
-    def trades(self, market: str, options: anydict | None = None) -> list[anydict] | errordict:
+    def trades(
+        self,
+        market: str,
+        options: anydict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[anydict] | errordict | Any:
         """Get all historic trades from this account
 
         ---
@@ -1479,44 +2052,57 @@ class Bitvavo:
         ```python
         market="BTC-EUR"
         options={
-            "limit": [ 1 .. 1000 ], default 500
-            "start": int timestamp in ms >= 0
-            "end": int timestamp in ms <= 8_640_000_000_000_000 # (that's somewhere in the year 2243, or near the number 2^52)
-            "tradeIdFrom": ""  # if you get a list and want everything AFTER a certain id, put that id here
-            "tradeIdTo": ""  # if you get a list and want everything BEFORE a certain id, put that id here
+          "limit": [ 1 .. 1000 ], default 500
+          "start": int timestamp in ms >= 0
+          "end": int timestamp in ms <= 8_640_000_000_000_000 # (that's somewhere in the year 2243, or near the number 2^52)
+          "tradeIdFrom": ""  # if you get a list and want everything AFTER a certain id, put that id here
+          "tradeIdTo": ""  # if you get a list and want everything BEFORE a certain id, put that id here
         }
-        ```
 
+        # Output format selection:
+        output_format=OutputFormat.DICT      # Default: returns standard Python dict/list
+        output_format=OutputFormat.PANDAS    # Returns pandas DataFrame
+        output_format=OutputFormat.POLARS    # Returns polars DataFrame
+        output_format=OutputFormat.CUDF      # Returns NVIDIA cuDF (GPU-accelerated)
+        output_format=OutputFormat.MODIN     # Returns modin (distributed pandas)
+        output_format=OutputFormat.PYARROW   # Returns Apache Arrow Table
+        output_format=OutputFormat.DASK      # Returns Dask DataFrame (distributed)
+        output_format=OutputFormat.DUCKDB    # Returns DuckDB relation
+        output_format=OutputFormat.IBIS      # Returns Ibis expression
+        output_format=OutputFormat.PYSPARK   # Returns PySpark DataFrame
+        output_format=OutputFormat.PYSPARK_CONNECT  # Returns PySpark Connect DataFrame
+        output_format=OutputFormat.SQLFRAME  # Returns SQLFrame DataFrame
+        ```
         ---
         Rate Limit Weight:
         ```python
         5
         ```
-
         ---
         Returns:
         ```python
         [
           {
-            "id": "108c3633-0276-4480-a902-17a01829deae",
-            "orderId": "1d671998-3d44-4df4-965f-0d48bd129a1b",
-            "timestamp": 1542967486256,
-            "market": "BTC-EUR",
-            "side": "buy",
-            "amount": "0.005",
-            "price": "5000.1",
-            "taker": true,
-            "fee": "0.03",
-            "feeCurrency": "EUR",
-            "settled": true
+          "id": "108c3633-0276-4480-a902-17a01829deae",
+          "orderId": "1d671998-3d44-4df4-965f-0d48bd129a1b",
+          "timestamp": 1542967486256,
+          "market": "BTC-EUR",
+          "side": "buy",
+          "amount": "0.005",
+          "price": "5000.1",
+          "taker": true,
+          "fee": "0.03",
+          "feeCurrency": "EUR",
+          "settled": true
           }
         ]
         ```
         """  # noqa: E501
         options = _default(options, {})
         options["market"] = market
-        postfix = createPostfix(options)
-        return self.privateRequest("/trades", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.private_request("/trades", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        return convert_to_dataframe(result, output_format)
 
     def account(self) -> dict[str, strdict]:
         """Get all fees for this account
@@ -1539,7 +2125,7 @@ class Bitvavo:
         }
         ```
         """
-        return self.privateRequest("/account", "", {}, "GET")  # type: ignore[return-value]
+        return self.private_request("/account", "", {}, "GET")  # type: ignore[return-value]
 
     def fees(self, market: str | None = None, quote: str | None = None) -> list[strdict] | errordict:
         """Get market fees for a specific market or quote currency
@@ -1576,10 +2162,14 @@ class Bitvavo:
             options["market"] = market
         if quote is not None:
             options["quote"] = quote
-        postfix = createPostfix(options)
-        return self.privateRequest("/account/fees", postfix, {}, "GET")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/account/fees", postfix, {}, "GET")  # type: ignore[return-value]
 
-    def balance(self, options: strdict | None = None) -> list[strdict] | errordict:
+    def balance(
+        self,
+        options: strdict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[strdict] | errordict | Any:
         """Get the balance for this account
 
         ---
@@ -1587,6 +2177,23 @@ class Bitvavo:
         ```python
         options={}  # return all balances
         options={symbol="BTC"} # return a single balance
+
+        # Output format selection:
+        output_format=OutputFormat.DICT      # Default: returns standard Python dict/list
+        output_format=OutputFormat.PANDAS    # Returns pandas DataFrame
+        output_format=OutputFormat.POLARS    # Returns polars DataFrame
+        output_format=OutputFormat.CUDF      # Returns NVIDIA cuDF (GPU-accelerated)
+        output_format=OutputFormat.MODIN     # Returns modin (distributed pandas)
+        output_format=OutputFormat.PYARROW   # Returns Apache Arrow Table
+        output_format=OutputFormat.DASK      # Returns Dask DataFrame (distributed)
+        output_format=OutputFormat.DUCKDB    # Returns DuckDB relation
+        output_format=OutputFormat.IBIS      # Returns Ibis expression
+        output_format=OutputFormat.PYSPARK   # Returns PySpark DataFrame
+        output_format=OutputFormat.PYSPARK_CONNECT  # Returns PySpark Connect DataFrame
+        output_format=OutputFormat.SQLFRAME  # Returns SQLFrame DataFrame
+
+        # Note: DataFrame formats require narwhals and the respective library to be installed.
+        # Install with: pip install 'bitvavo-api-upgraded[pandas]' or similar for other formats.
         ```
 
         ---
@@ -1598,6 +2205,7 @@ class Bitvavo:
         ---
         Returns:
         ```python
+        # When output_format='dict' (default):
         [
           {
             "symbol": "BTC",
@@ -1605,12 +2213,21 @@ class Bitvavo:
             "inOrder": "0.74832374"
           }
         ]
+
+        # When output_format is any DataFrame format:
+        # Returns the above data as a DataFrame in the requested format (pandas, polars, etc.)
+        # with columns: symbol, available, inOrder
         ```
         """
-        postfix = createPostfix(options)
-        return self.privateRequest("/balance", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.private_request("/balance", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        return convert_to_dataframe(result, output_format)
 
+    @deprecated(version="2.2.0", reason="Use account_history instead")
     def accountHistory(self, options: strintdict | None = None) -> anydict | errordict:
+        return self.account_history(options)
+
+    def account_history(self, options: strintdict | None = None) -> anydict | errordict:
         """Get all past transactions for your account
 
         ---
@@ -1654,10 +2271,14 @@ class Bitvavo:
         }
         ```
         """
-        postfix = createPostfix(options)
-        return self.privateRequest("/account/history", postfix, {}, "GET")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/account/history", postfix, {}, "GET")  # type: ignore[return-value]
 
+    @deprecated(version="2.2.0", reason="Use deposit_assets instead")
     def depositAssets(self, symbol: str) -> strdict:
+        return self.deposit_assets(symbol)
+
+    def deposit_assets(self, symbol: str) -> strdict:
         """Get the deposit address (with paymentId for some assets) or bank account information to increase your balance
 
         ---
@@ -1689,10 +2310,14 @@ class Bitvavo:
         }
         ```
         """
-        postfix = createPostfix({"symbol": symbol})
-        return self.privateRequest("/deposit", postfix, {}, "GET")  # type: ignore[return-value]
+        postfix = create_postfix({"symbol": symbol})
+        return self.private_request("/deposit", postfix, {}, "GET")  # type: ignore[return-value]
 
+    @deprecated(version="2.2.0", reason="Use deposit_history instead")
     def depositHistory(self, options: anydict | None = None) -> list[anydict] | errordict:
+        return self.deposit_history(options)
+
+    def deposit_history(self, options: anydict | None = None) -> list[anydict] | errordict:
         """Get the deposit history of the account
 
         Even when you want something from a single `symbol`, you'll still receive a list with multiple deposits.
@@ -1740,10 +2365,14 @@ class Bitvavo:
         ]
         ```
         """  # noqa: E501
-        postfix = createPostfix(options)
-        return self.privateRequest("/depositHistory", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/depositHistory", postfix, {}, "GET", 5)  # type: ignore[return-value]
 
+    @deprecated(version="2.2.0", reason="Use withdraw_assets instead")
     def withdrawAssets(self, symbol: str, amount: str, address: str, body: anydict) -> anydict:
+        return self.withdraw_assets(symbol, amount, address, body)
+
+    def withdraw_assets(self, symbol: str, amount: str, address: str, body: anydict) -> anydict:
         """Withdraw a coin/token to an external crypto address or bank account.
 
         ---
@@ -1778,9 +2407,21 @@ class Bitvavo:
         body["symbol"] = symbol
         body["amount"] = amount
         body["address"] = address
-        return self.privateRequest("/withdrawal", "", body, "POST")  # type: ignore[return-value]
+        return self.private_request("/withdrawal", "", body, "POST")  # type: ignore[return-value]
+
+    @deprecated(version="2.2.0", reason="Use withdrawal_history instead")
+    def withdrawalHistory(
+        self,
+        options: anydict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[anydict] | errordict | Any:
+        return self.withdrawal_history(options, output_format)
 
-    def withdrawalHistory(self, options: anydict | None = None) -> list[anydict] | errordict:
+    def withdrawal_history(
+        self,
+        options: anydict | None = None,
+        output_format: OutputFormat = OutputFormat.DICT,
+    ) -> list[anydict] | errordict | Any:
         """Get the withdrawal history
 
         ---
@@ -1792,8 +2433,24 @@ class Bitvavo:
             "start": int timestamp in ms >= 0
             "end": int timestamp in ms <= 8_640_000_000_000_000 # (that's somewhere in the year 2243, or near the number 2^52)
         }
-        ```
 
+        # Output format selection:
+        output_format=OutputFormat.DICT      # Default: returns standard Python dict/list
+        output_format=OutputFormat.PANDAS    # Returns pandas DataFrame
+        output_format=OutputFormat.POLARS    # Returns polars DataFrame
+        output_format=OutputFormat.CUDF      # Returns NVIDIA cuDF (GPU-accelerated)
+        output_format=OutputFormat.MODIN     # Returns modin (distributed pandas)
+        output_format=OutputFormat.PYARROW   # Returns Apache Arrow Table
+        output_format=OutputFormat.DASK      # Returns Dask DataFrame (distributed)
+        output_format=OutputFormat.DUCKDB    # Returns DuckDB relation
+        output_format=OutputFormat.IBIS      # Returns Ibis expression
+        output_format=OutputFormat.PYSPARK   # Returns PySpark DataFrame
+        output_format=OutputFormat.PYSPARK_CONNECT  # Returns PySpark Connect DataFrame
+        output_format=OutputFormat.SQLFRAME  # Returns SQLFrame DataFrame
+
+        # Note: DataFrame formats require narwhals and the respective library to be installed.
+        # Install with: pip install 'bitvavo-api-upgraded[pandas]' or similar for other formats.
+        ```
         ---
         Rate Limit Weight:
         ```python
@@ -1814,13 +2471,130 @@ class Bitvavo:
             "fee": "0.00006",
             "status": "awaiting_processing"
           }
-        }
+        ]
         ```
         """  # noqa: E501
-        postfix = createPostfix(options)
-        return self.privateRequest("/withdrawalHistory", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.private_request("/withdrawalHistory", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        return convert_to_dataframe(result, output_format)
+
+    # API Key Management Helper Methods
+
+    def add_api_key(self, api_key: str, api_secret: str) -> None:
+        """Add a new API key to the available keys.
+
+        Args:
+            api_key: The API key to add
+            api_secret: The corresponding API secret
+        """
+        new_key = {"key": api_key, "secret": api_secret}
+        self.api_keys.append(new_key)
+
+        # Initialize rate limit tracking for this key using settings default
+        key_index = len(self.api_keys) - 1
+        default_rate_limit = bitvavo_upgraded_settings.DEFAULT_RATE_LIMIT
+        self.rate_limits[key_index] = {"remaining": default_rate_limit, "resetAt": ms(0)}
+
+        logger.info("api-key-added", key_index=key_index)
+
+    def remove_api_key(self, api_key: str) -> bool:
+        """Remove an API key from the available keys.
+
+        Args:
+            api_key: The API key to remove
+
+        Returns:
+            bool: True if the key was found and removed, False otherwise
+        """
+        for i, key_data in enumerate(self.api_keys):
+            if key_data["key"] == api_key:
+                _ = self.api_keys.pop(i)
+                # Remove rate limit tracking for this key
+                if i in self.rate_limits:
+                    del self.rate_limits[i]
+                # Update rate limit tracking indices (shift them down)
+                new_rate_limits = {}
+                for key_idx, limits in self.rate_limits.items():
+                    if key_idx == -1 or key_idx < i:  # keyless
+                        new_rate_limits[key_idx] = limits
+                    elif key_idx > i:
+                        new_rate_limits[key_idx - 1] = limits
+                self.rate_limits = new_rate_limits
+
+                # Update current index if needed
+                if self.current_api_key_index >= i:
+                    self.current_api_key_index = max(0, self.current_api_key_index - 1)
+
+                logger.info("api-key-removed", key_index=i)
+                return True
+        return False
+
+    def get_api_key_status(self) -> dict[str, dict[str, int | str | bool]]:
+        """Get the current status of all API keys including rate limits.
 
+        Returns:
+            dict: Status information for keyless and all API keys
+        """
+        status = {}
+
+        # Keyless status
+        keyless_limits = self.rate_limits.get(-1, {"remaining": 0, "resetAt": ms(0)})
+        status["keyless"] = {
+            "remaining": int(keyless_limits["remaining"]),
+            "resetAt": int(keyless_limits["resetAt"]),
+            "available": self._has_rate_limit_available(-1, 1),
+        }
+
+        # API key status
+        for i, key_data in enumerate(self.api_keys):
+            key_limits = self.rate_limits.get(i, {"remaining": 0, "resetAt": ms(0)})
+            KEY_LENGTH = 12
+            key_masked = (
+                key_data["key"][:8] + "..." + key_data["key"][-4:]
+                if len(key_data["key"]) > KEY_LENGTH
+                else key_data["key"]
+            )
+            status[f"api_key_{i}"] = {
+                "key": key_masked,
+                "remaining": int(key_limits["remaining"]),
+                "resetAt": int(key_limits["resetAt"]),
+                "available": self._has_rate_limit_available(i, 1),
+            }
+
+        return status
+
+    def set_keyless_preference(self, prefer_keyless: bool) -> None:  # noqa: FBT001 (Boolean-typed positional argument in function definition)
+        """Set whether to prefer keyless requests.
+
+        Args:
+            prefer_keyless: If True, use keyless requests first when available
+        """
+        self.prefer_keyless = prefer_keyless
+        logger.info("keyless-preference-changed", prefer_keyless=prefer_keyless)
+
+    def get_current_config(self) -> dict[str, str | bool | int]:
+        """Get the current configuration.
+
+        Returns:
+            dict: Current configuration including key count and preferences
+        """
+        KEY_LENGTH = 12
+        return {
+            "api_key_count": len(self.api_keys),
+            "prefer_keyless": self.prefer_keyless,
+            "current_api_key_index": self.current_api_key_index,
+            "current_api_key": self._current_api_key[:8] + "..." + self._current_api_key[-4:]
+            if len(self._current_api_key) > KEY_LENGTH
+            else self._current_api_key,
+            "rate_limit_remaining": self.rateLimitRemaining,
+            "rate_limit_reset_at": int(self.rateLimitResetAt),
+        }
+
+    @deprecated(version="2.2.0", reason="Use new_websocket instead")
     def newWebsocket(self) -> Bitvavo.WebSocketAppFacade:
+        return self.new_websocket()
+
+    def new_websocket(self) -> Bitvavo.WebSocketAppFacade:
         return Bitvavo.WebSocketAppFacade(self.APIKEY, self.APISECRET, self.ACCESSWINDOW, self.wsUrl, self)
 
     class WebSocketAppFacade:
@@ -1869,18 +2643,30 @@ class Bitvavo:
             self.keepBookCopy = False
             self.localBook: anydict = {}
 
+        @deprecated(version="2.2.0", reason="Use close_socket instead")
         def closeSocket(self) -> None:
+            return self.close_socket()
+
+        def close_socket(self) -> None:
             self.ws.close()
             self.keepAlive = False
             self.receiveThread.join()
 
-        def waitForSocket(self, ws: WebSocketApp, message: str, private: bool) -> None:  # noqa: ARG002, FBT001
-            while True:
+        @deprecated(version="2.2.0", reason="Use wait_for_socket instead")
+        def waitForSocket(self, ws: WebSocketApp, message: str, private: bool) -> None:  # noqa: FBT001
+            return self.wait_for_socket(ws, message, private)
+
+        def wait_for_socket(self, ws: WebSocketApp, message: str, private: bool) -> None:  # noqa: ARG002, FBT001
+            while self.keepAlive:
                 if (not private and self.open) or (private and self.authenticated and self.open):
                     return
                 time.sleep(0.1)
 
+        @deprecated(version="2.2.0", reason="Use do_send instead")
         def doSend(self, ws: WebSocketApp, message: str, private: bool = False) -> None:  # noqa: FBT001, FBT002
+            return self.do_send(ws, message, private)
+
+        def do_send(self, ws: WebSocketApp, message: str, private: bool = False) -> None:  # noqa: FBT001, FBT002
             # TODO(NostraDavid): add nap-time to the websocket, or do it here; I don't know yet.
             if private and self.APIKEY == "":
                 logger.error(
@@ -1888,7 +2674,7 @@ class Bitvavo:
                     tip="set the API key to be able to make private API calls",
                 )
                 return
-            self.waitForSocket(ws, message, private)
+            self.wait_for_socket(ws, message, private)
             ws.send(message)
             if self.bitvavo.debugging:
                 logger.debug("message-sent", message=message)
@@ -1901,7 +2687,7 @@ class Bitvavo:
 
             if "error" in msg_dict:
                 if msg_dict["errorCode"] == 105:  # noqa: PLR2004
-                    self.bitvavo.updateRateLimit(msg_dict)
+                    self.bitvavo.update_rate_limit(msg_dict)
                 if "error" in callbacks:
                     callbacks["error"](msg_dict)
                 else:
@@ -1989,6 +2775,8 @@ class Bitvavo:
                         callbacks["subscriptionTrades"][market](msg_dict)
 
         def on_error(self, ws: Any, error: Any) -> None:  # noqa: ARG002
+            # Stop the receive thread on error to prevent hanging
+            self.receiveThread.stop()
             if "error" in self.callbacks:
                 self.callbacks["error"](error)
             else:
@@ -1999,47 +2787,51 @@ class Bitvavo:
             if self.bitvavo.debugging:
                 logger.debug("websocket-closed")
 
-        def checkReconnect(self) -> None:  # noqa: C901, PLR0912 (too-complex)
+        @deprecated(version="2.2.0", reason="Use check_reconnect instead")
+        def checkReconnect(self) -> None:
+            return self.check_reconnect()
+
+        def check_reconnect(self) -> None:  # noqa: C901, PLR0912 (too-complex)
             if "subscriptionTicker" in self.callbacks:
                 for market in self.callbacks["subscriptionTicker"]:
-                    self.subscriptionTicker(market, self.callbacks["subscriptionTicker"][market])
+                    self.subscription_ticker(market, self.callbacks["subscriptionTicker"][market])
             if "subscriptionTicker24h" in self.callbacks:
                 for market in self.callbacks["subscriptionTicker24h"]:
-                    self.subscriptionTicker(market, self.callbacks["subscriptionTicker24h"][market])
+                    self.subscription_ticker(market, self.callbacks["subscriptionTicker24h"][market])
             if "subscriptionAccount" in self.callbacks:
                 for market in self.callbacks["subscriptionAccount"]:
-                    self.subscriptionAccount(market, self.callbacks["subscriptionAccount"][market])
+                    self.subscription_account(market, self.callbacks["subscriptionAccount"][market])
             if "subscriptionCandles" in self.callbacks:
                 for market in self.callbacks["subscriptionCandles"]:
                     for interval in self.callbacks["subscriptionCandles"][market]:
-                        self.subscriptionCandles(
+                        self.subscription_candles(
                             market,
                             interval,
                             self.callbacks["subscriptionCandles"][market][interval],
                         )
             if "subscriptionTrades" in self.callbacks:
                 for market in self.callbacks["subscriptionTrades"]:
-                    self.subscriptionTrades(market, self.callbacks["subscriptionTrades"][market])
+                    self.subscription_trades(market, self.callbacks["subscriptionTrades"][market])
             if "subscriptionBookUpdate" in self.callbacks:
                 for market in self.callbacks["subscriptionBookUpdate"]:
-                    self.subscriptionBookUpdate(market, self.callbacks["subscriptionBookUpdate"][market])
+                    self.subscription_book_update(market, self.callbacks["subscriptionBookUpdate"][market])
             if "subscriptionBookUser" in self.callbacks:
                 for market in self.callbacks["subscriptionBookUser"]:
-                    self.subscriptionBook(market, self.callbacks["subscriptionBookUser"][market])
+                    self.subscription_book(market, self.callbacks["subscriptionBookUser"][market])
 
         def on_open(self, ws: Any) -> None:  # noqa: ARG002
             now = time_ms() + bitvavo_upgraded_settings.LAG
             self.open = True
             self.reconnectTimer = 0.5
             if self.APIKEY != "":
-                self.doSend(
+                self.do_send(
                     self.ws,
                     json.dumps(
                         {
                             "window": str(self.ACCESSWINDOW),
                             "action": "authenticate",
                             "key": self.APIKEY,
-                            "signature": createSignature(now, "GET", "/websocket", {}, self.APISECRET),
+                            "signature": create_signature(now, "GET", "/websocket", {}, self.APISECRET),
                             "timestamp": now,
                         },
                     ),
@@ -2047,10 +2839,14 @@ class Bitvavo:
             if self.reconnect:
                 if self.bitvavo.debugging:
                     logger.debug("reconnecting")
-                thread = Thread(target=self.checkReconnect)
+                thread = Thread(target=self.check_reconnect)
                 thread.start()
 
+        @deprecated(version="2.2.0", reason="Use set_error_callback instead")
         def setErrorCallback(self, callback: Callable[[Any], None]) -> None:
+            return self.set_error_callback(callback)
+
+        def set_error_callback(self, callback: Callable[[Any], None]) -> None:
             self.callbacks["error"] = callback
 
         def time(self, callback: Callable[[Any], None]) -> None:
@@ -2078,7 +2874,7 @@ class Bitvavo:
             ```
             """
             self.callbacks["time"] = callback
-            self.doSend(self.ws, json.dumps({"action": "getTime"}))
+            self.do_send(self.ws, json.dumps({"action": "getTime"}))
 
         def markets(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get all available markets with some meta-information, unless options is given a `market` key.
@@ -2132,7 +2928,7 @@ class Bitvavo:
             """
             self.callbacks["markets"] = callback
             options["action"] = "getMarkets"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
         def assets(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get all available assets, unless `options` is given a `symbol` key.
@@ -2183,7 +2979,7 @@ class Bitvavo:
             """
             self.callbacks["assets"] = callback
             options["action"] = "getAssets"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
         def book(self, market: str, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get a book (with two lists: asks and bids, as they're called)
@@ -2230,7 +3026,7 @@ class Bitvavo:
             self.callbacks["book"] = callback
             options["market"] = market
             options["action"] = "getBook"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
         def publicTrades(self, market: str, options: anydict, callback: Callable[[Any], None]) -> None:
             """Publically available trades
@@ -2282,7 +3078,7 @@ class Bitvavo:
             self.callbacks["publicTrades"] = callback
             options["market"] = market
             options["action"] = "getTrades"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
         def candles(
             self,
@@ -2341,9 +3137,13 @@ class Bitvavo:
             options["market"] = market
             options["interval"] = interval
             options["action"] = "getCandles"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
+        @deprecated(version="2.2.0", reason="Use ticker_price instead")
         def tickerPrice(self, options: anydict, callback: Callable[[Any], None]) -> None:
+            return self.ticker_price(options, callback)
+
+        def ticker_price(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get the current price for each market
 
             ---
@@ -2391,9 +3191,13 @@ class Bitvavo:
             """
             self.callbacks["tickerPrice"] = callback
             options["action"] = "getTickerPrice"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
+        @deprecated(version="2.2.0", reason="Use ticker_book instead")
         def tickerBook(self, options: anydict, callback: Callable[[Any], None]) -> None:
+            return self.ticker_book(options, callback)
+
+        def ticker_book(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get current bid/ask, bidsize/asksize per market
 
             ---
@@ -2434,7 +3238,7 @@ class Bitvavo:
             """  # noqa: E501
             self.callbacks["tickerBook"] = callback
             options["action"] = "getTickerBook"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
         def ticker24h(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get current bid/ask, bidsize/asksize per market
@@ -2501,8 +3305,9 @@ class Bitvavo:
             """
             self.callbacks["ticker24h"] = callback
             options["action"] = "getTicker24h"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
+        @deprecated(version="2.2.0", reason="Use place_order instead")
         def placeOrder(
             self,
             market: str,
@@ -2511,6 +3316,17 @@ class Bitvavo:
             operatorId: int,
             body: anydict,
             callback: Callable[[Any], None],
+        ) -> None:
+            return self.place_order(market, side, orderType, operatorId, body, callback)
+
+        def place_order(
+            self,
+            market: str,
+            side: str,
+            orderType: str,
+            operatorId: int,
+            body: anydict,
+            callback: Callable[[Any], None],
         ) -> None:
             """Place a new order on the exchange
 
@@ -2643,8 +3459,9 @@ class Bitvavo:
             body["orderType"] = orderType
             body["operatorId"] = operatorId
             body["action"] = "privateCreateOrder"
-            self.doSend(self.ws, json.dumps(body), True)
+            self.do_send(self.ws, json.dumps(body), True)
 
+        @deprecated(version="2.2.0", reason="Use update_order instead")
         def updateOrder(
             self,
             market: str,
@@ -2652,6 +3469,16 @@ class Bitvavo:
             operatorId: int,
             body: anydict,
             callback: Callable[[Any], None],
+        ) -> None:
+            return self.update_order(market, orderId, operatorId, body, callback)
+
+        def update_order(
+            self,
+            market: str,
+            orderId: str,
+            operatorId: int,
+            body: anydict,
+            callback: Callable[[Any], None],
         ) -> None:
             """
             Update an existing order for a specific market. Make sure that at least one of the optional parameters
@@ -2741,8 +3568,9 @@ class Bitvavo:
             body["orderId"] = orderId
             body["operatorId"] = operatorId
             body["action"] = "privateUpdateOrder"
-            self.doSend(self.ws, json.dumps(body), True)
+            self.do_send(self.ws, json.dumps(body), True)
 
+        @deprecated(version="2.2.0", reason="Use cancel_order instead")
         def cancelOrder(
             self,
             market: str,
@@ -2750,6 +3578,16 @@ class Bitvavo:
             callback: Callable[[Any], None],
             orderId: str | None = None,
             clientOrderId: str | None = None,
+        ) -> None:
+            return self.cancel_order(market, operatorId, callback, orderId, clientOrderId)
+
+        def cancel_order(
+            self,
+            market: str,
+            operatorId: int,
+            callback: Callable[[Any], None],
+            orderId: str | None = None,
+            clientOrderId: str | None = None,
         ) -> None:
             """Cancel an existing order for a specific market
 
@@ -2793,9 +3631,13 @@ class Bitvavo:
             elif orderId is not None:
                 options["orderId"] = orderId
 
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
+        @deprecated(version="2.2.0", reason="Use get_order instead")
         def getOrder(self, market: str, orderId: str, callback: Callable[[Any], None]) -> None:
+            return self.get_order(market, orderId, callback)
+
+        def get_order(self, market: str, orderId: str, callback: Callable[[Any], None]) -> None:
             """Get an existing order for a specific market
 
             ---
@@ -2864,9 +3706,13 @@ class Bitvavo:
                 "market": market,
                 "orderId": orderId,
             }
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
+        @deprecated(version="2.2.0", reason="Use get_orders instead")
         def getOrders(self, market: str, options: anydict, callback: Callable[[Any], None]) -> None:
+            return self.get_orders(market, options, callback)
+
+        def get_orders(self, market: str, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get multiple existing orders for a specific market
 
             ---
@@ -2944,9 +3790,13 @@ class Bitvavo:
             self.callbacks["getOrders"] = callback
             options["action"] = "privateGetOrders"
             options["market"] = market
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
+        @deprecated(version="2.2.0", reason="Use cancel_orders instead")
         def cancelOrders(self, options: anydict, callback: Callable[[Any], None]) -> None:
+            return self.cancel_orders(options, callback)
+
+        def cancel_orders(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Cancel all existing orders for a specific market (or account)
 
             ---
@@ -2974,9 +3824,13 @@ class Bitvavo:
             """
             self.callbacks["cancelOrders"] = callback
             options["action"] = "privateCancelOrders"
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
+        @deprecated(version="2.2.0", reason="Use orders_open instead")
         def ordersOpen(self, options: anydict, callback: Callable[[Any], None]) -> None:
+            return self.orders_open(options, callback)
+
+        def orders_open(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get all open orders, either for all markets, or a single market
 
             ---
@@ -3044,7 +3898,7 @@ class Bitvavo:
             """
             self.callbacks["ordersOpen"] = callback
             options["action"] = "privateGetOrdersOpen"
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
         def trades(self, market: str, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get all historic trades from this account
@@ -3093,7 +3947,7 @@ class Bitvavo:
             self.callbacks["trades"] = callback
             options["action"] = "privateGetTrades"
             options["market"] = market
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
         def account(self, callback: Callable[[Any], None]) -> None:
             """Get all fees for this account
@@ -3123,7 +3977,7 @@ class Bitvavo:
             ```
             """
             self.callbacks["account"] = callback
-            self.doSend(self.ws, json.dumps({"action": "privateGetAccount"}), True)
+            self.do_send(self.ws, json.dumps({"action": "privateGetAccount"}), True)
 
         def balance(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get the balance for this account
@@ -3156,9 +4010,13 @@ class Bitvavo:
             """
             options["action"] = "privateGetBalance"
             self.callbacks["balance"] = callback
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
+        @deprecated(version="2.2.0", reason="Use deposit_assets instead")
         def depositAssets(self, symbol: str, callback: Callable[[Any], None]) -> None:
+            return self.deposit_assets(symbol, callback)
+
+        def deposit_assets(self, symbol: str, callback: Callable[[Any], None]) -> None:
             """
             Get the deposit address (with paymentId for some assets) or bank account information to increase your
             balance.
@@ -3194,13 +4052,17 @@ class Bitvavo:
             ```
             """
             self.callbacks["depositAssets"] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps({"action": "privateDepositAssets", "symbol": symbol}),
                 True,
             )
 
+        @deprecated(version="2.2.0", reason="Use deposit_history instead")
         def depositHistory(self, options: anydict, callback: Callable[[Any], None]) -> None:
+            return self.deposit_history(options, callback)
+
+        def deposit_history(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get the deposit history of the account
 
             Even when you want something from a single `symbol`, you'll still receive a list with multiple deposits.
@@ -3252,8 +4114,9 @@ class Bitvavo:
             """
             self.callbacks["depositHistory"] = callback
             options["action"] = "privateGetDepositHistory"
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
+        @deprecated(version="2.2.0", reason="Use withdraw_assets instead")
         def withdrawAssets(
             self,
             symbol: str,
@@ -3261,6 +4124,16 @@ class Bitvavo:
             address: str,
             body: anydict,
             callback: Callable[[Any], None],
+        ) -> None:
+            return self.withdraw_assets(symbol, amount, address, body, callback)
+
+        def withdraw_assets(
+            self,
+            symbol: str,
+            amount: str,
+            address: str,
+            body: anydict,
+            callback: Callable[[Any], None],
         ) -> None:
             """Withdraw a coin/token to an external crypto address or bank account.
 
@@ -3305,9 +4178,13 @@ class Bitvavo:
             body["symbol"] = symbol
             body["amount"] = amount
             body["address"] = address
-            self.doSend(self.ws, json.dumps(body), True)
+            self.do_send(self.ws, json.dumps(body), True)
 
+        @deprecated(version="2.2.0", reason="Use withdrawal_history instead")
         def withdrawalHistory(self, options: anydict, callback: Callable[[Any], None]) -> None:
+            return self.withdrawal_history(options, callback)
+
+        def withdrawal_history(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get the withdrawal history
 
             ---
@@ -3348,9 +4225,13 @@ class Bitvavo:
             """
             self.callbacks["withdrawalHistory"] = callback
             options["action"] = "privateGetWithdrawalHistory"
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
+        @deprecated(version="2.2.0", reason="Use subscription_ticker instead")
         def subscriptionTicker(self, market: str, callback: Callable[[Any], None]) -> None:
+            return self.subscription_ticker(market, callback)
+
+        def subscription_ticker(self, market: str, callback: Callable[[Any], None]) -> None:
             # TODO(NostraDavid): one possible improvement here is to turn `market` into a list of markets, so we can sub
             # to all of them at once. Same goes for other `subscription*()`
             """
@@ -3392,7 +4273,7 @@ class Bitvavo:
             if "subscriptionTicker" not in self.callbacks:
                 self.callbacks["subscriptionTicker"] = {}
             self.callbacks["subscriptionTicker"][market] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -3402,7 +4283,11 @@ class Bitvavo:
                 ),
             )
 
+        @deprecated(version="2.2.0", reason="Use subscription_ticker24h instead")
         def subscriptionTicker24h(self, market: str, callback: Callable[[Any], None]) -> None:
+            return self.subscription_ticker24h(market, callback)
+
+        def subscription_ticker24h(self, market: str, callback: Callable[[Any], None]) -> None:
             """
             Subscribe to the ticker-24-hour channel, which means `callback` gets passed the new object every second, if
             values have changed.
@@ -3449,7 +4334,7 @@ class Bitvavo:
             if "subscriptionTicker24h" not in self.callbacks:
                 self.callbacks["subscriptionTicker24h"] = {}
             self.callbacks["subscriptionTicker24h"][market] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -3459,7 +4344,11 @@ class Bitvavo:
                 ),
             )
 
+        @deprecated(version="2.2.0", reason="Use subscription_account instead")
         def subscriptionAccount(self, market: str, callback: Callable[[Any], None]) -> None:
+            return self.subscription_account(market, callback)
+
+        def subscription_account(self, market: str, callback: Callable[[Any], None]) -> None:
             """
             Subscribes to the account channel, which sends an update whenever an event happens which is related to
             the account. These are 'order' events (create, update, cancel) or 'fill' events (a trade occurred).
@@ -3526,7 +4415,7 @@ class Bitvavo:
             if "subscriptionAccount" not in self.callbacks:
                 self.callbacks["subscriptionAccount"] = {}
             self.callbacks["subscriptionAccount"][market] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -3537,7 +4426,11 @@ class Bitvavo:
                 True,
             )
 
+        @deprecated(version="2.2.0", reason="Use subscription_candles instead")
         def subscriptionCandles(self, market: str, interval: str, callback: Callable[[Any], None]) -> None:
+            return self.subscription_candles(market, interval, callback)
+
+        def subscription_candles(self, market: str, interval: str, callback: Callable[[Any], None]) -> None:
             """Subscribes to candles and returns a candle each time a new one is formed, depending on the interval
 
             ---
@@ -3585,7 +4478,7 @@ class Bitvavo:
             if market not in self.callbacks["subscriptionCandles"]:
                 self.callbacks["subscriptionCandles"][market] = {}
             self.callbacks["subscriptionCandles"][market][interval] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -3601,7 +4494,11 @@ class Bitvavo:
                 ),
             )
 
+        @deprecated(version="2.2.0", reason="Use subscription_trades instead")
         def subscriptionTrades(self, market: str, callback: Callable[[Any], None]) -> None:
+            return self.subscription_trades(market, callback)
+
+        def subscription_trades(self, market: str, callback: Callable[[Any], None]) -> None:
             """Subscribes to trades, which sends an object whenever a trade has occurred.
 
             ---
@@ -3638,7 +4535,7 @@ class Bitvavo:
             if "subscriptionTrades" not in self.callbacks:
                 self.callbacks["subscriptionTrades"] = {}
             self.callbacks["subscriptionTrades"][market] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -3648,7 +4545,11 @@ class Bitvavo:
                 ),
             )
 
+        @deprecated(version="2.2.0", reason="Use subscription_book_update instead")
         def subscriptionBookUpdate(self, market: str, callback: Callable[[Any], None]) -> None:
+            return self.subscription_book_update(market, callback)
+
+        def subscription_book_update(self, market: str, callback: Callable[[Any], None]) -> None:
             """Subscribes to the book and returns a delta on every change to the book.
 
             ---
@@ -3705,7 +4606,7 @@ class Bitvavo:
             if "subscriptionBookUpdate" not in self.callbacks:
                 self.callbacks["subscriptionBookUpdate"] = {}
             self.callbacks["subscriptionBookUpdate"][market] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -3715,7 +4616,11 @@ class Bitvavo:
                 ),
             )
 
+        @deprecated(version="2.2.0", reason="Use subscription_book instead")
         def subscriptionBook(self, market: str, callback: Callable[[Any], None]) -> None:
+            return self.subscription_book(market, callback)
+
+        def subscription_book(self, market: str, callback: Callable[[Any], None]) -> None:
             """Subscribes to the book and returns a delta on every change to the book.
 
             ---
@@ -3775,8 +4680,8 @@ class Bitvavo:
             self.callbacks["subscriptionBookUser"][market] = callback
             if "subscriptionBook" not in self.callbacks:
                 self.callbacks["subscriptionBook"] = {}
-            self.callbacks["subscriptionBook"][market] = processLocalBook
-            self.doSend(
+            self.callbacks["subscriptionBook"][market] = process_local_book
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -3787,4 +4692,4 @@ class Bitvavo:
             )
 
             self.localBook[market] = {}
-            self.doSend(self.ws, json.dumps({"action": "getBook", "market": market}))
+            self.do_send(self.ws, json.dumps({"action": "getBook", "market": market}))