fxsocket 0.6.0__tar.gz → 0.8.0__tar.gz

{fxsocket-0.6.0 → fxsocket-0.8.0}/.github/workflows/ci.yml

@@ -13,8 +13,8 @@ jobs:
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13"]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install

{fxsocket-0.6.0 → fxsocket-0.8.0}/.github/workflows/publish.yml

@@ -13,8 +13,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
         with:
           python-version: "3.12"
       - name: Build sdist + wheel
@@ -22,7 +22,7 @@ jobs:
           python -m pip install --upgrade build twine
           python -m build
           twine check dist/*
-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v7
         with:
           name: dist
           path: dist/
@@ -36,7 +36,7 @@ jobs:
     permissions:
       id-token: write # required for trusted publishing
     steps:
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           name: dist
           path: dist/
@@ -53,7 +53,7 @@ jobs:
     permissions:
       id-token: write # required for trusted publishing
     steps:
-      - uses: actions/download-artifact@v4
+      - uses: actions/download-artifact@v8
         with:
           name: dist
           path: dist/

fxsocket-0.8.0/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Releases
+up to 0.7.0 are described in their tagged commits.
+
+## [0.8.0] - 2026-10-26
+
+### Removed
+
+- `Timeframe.M2`, `M3`, `H2`, `H6`, `H8` and `H12`, and the `2min`, `3min`,
+  `2h`, `6h`, `8h` and `12h` aliases. The SDK treated them as MT5-only, but
+  neither terminal API serves them: MT4 and MT5 both accept exactly `M1`, `M5`,
+  `M15`, `M30`, `H1`, `H4`, `D1`, `W1` and `MN1`, in REST `price_history` and on
+  the `bars` stream. On an MT5 account they passed the SDK and the terminal
+  refused them (HTTP 400 from `price_history`, an `error` frame and no bars
+  from the stream).
+
+  They are removed rather than kept and rejected on both platforms, so that
+  `Timeframe` lists exactly what the server accepts: iterating it gives the
+  usable set, and type checkers flag the removed names. The only code this
+  breaks is code that could never succeed.
+
+### Changed
+
+- A timeframe outside those nine now raises `ValidationError` on both
+  platforms before anything is sent, and the message lists the accepted
+  labels. On MT4 the six removed ones used to raise
+  `UnsupportedOnPlatformError`, so code that caught that for timeframes should
+  catch `ValidationError` instead. Nothing raises `UnsupportedOnPlatformError`
+  now; it stays exported.
+
+### Deprecated
+
+- `fxsocket.enums.MT5_ONLY_TIMEFRAMES` is always empty and will be removed in
+  1.0.
+
+[0.8.0]: https://github.com/fxsocket-com/FxSocket-Python-SDK/releases/tag/v0.8.0

{fxsocket-0.6.0 → fxsocket-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fxsocket
-Version: 0.6.0
+Version: 0.8.0
 Summary: Python SDK for the FxSocket API — MT4/MT5 account management, trading, and real-time streaming.
 Project-URL: Homepage, https://fxsocket.com
 Project-URL: Documentation, https://api.fxsocket.com/v1/docs
@@ -232,8 +232,11 @@ in `order_modify`, a literal `stop_loss=0.0` would *remove* your stop-loss, so
 it's rejected — pass `clear_stop_loss=True` to remove one deliberately, while
 `None` (the default) keeps the current value.
 
-MT4 and MT5 share one interface. MT5-only timeframes (`M2`, `M3`, `H2`, `H6`,
-`H8`, `H12`) raise `UnsupportedOnPlatformError` on MT4 before any request.
+MT4 and MT5 share one interface, timeframes included. Both accept the same nine:
+`M1`, `M5`, `M15`, `M30`, `H1`, `H4`, `D1`, `W1`, `MN1` (or `1min`, `5min`,
+`15min`, `30min`, `1h`, `4h`, `1d`, `1w`, `1month`). MT5's other periods, such
+as `H2` or `H12`, aren't served by the terminal API, so anything else raises
+`ValidationError` before any request.
 
 > **MT4 history note:** on MT4, `price_history` with `from_`/`to` bounds (or the
 > `D1` timeframe) can fail server-side with `CopyRates failed` when the terminal
@@ -443,7 +446,8 @@ with Client(api_key="fxs_live_...", verify_terminal_tls=False) as fx:
             server, server="ICMarkets-Demo", login=1150125, password="..."
         )
     except SlotsFullError as err:
-        print(f"Server full ({err.used}/{err.cap}) — raise the limit in the dashboard.")
+        print(f"Server full ({err.used}/{err.cap})")
+        server = fx.private_servers.resize(server, slots=err.cap + 1)
 
     # Poll until the on-server agent has the terminal up, then trade as usual.
     while True:
@@ -460,8 +464,68 @@ Accounts on a private server are traded and streamed exactly like
 shared-cluster accounts — their `rest_url` / `ws_url` simply point at the
 server's dedicated IP. The server presents a self-signed certificate, so reach
 it with `Client(..., verify_terminal_tls=False)` (or supply a pinned CA).
-*Purchasing* a server, canceling, and slot changes happen in the dashboard;
-the API deliberately exposes no billing operations.
+
+`server.cancel_at_period_end` is `True` once a server has been told to stop
+instead of renewing; it then runs until `server.period_end` and expires.
+
+### Buying, resizing and canceling
+
+`fx.private_servers.regions()` returns where servers may run, how big they may
+be and what that costs — call it before buying rather than hardcoding slugs:
+
+```python
+options = fx.private_servers.regions()
+if options.enabled:
+    print(options.region_codes)                     # ['fra1', 'lon1', ...]
+    print(options.max_slots, options.max_servers)
+    print(options.monthly_price_eur(3))             # Decimal('45') — 3 slots/month
+```
+
+`create()` buys one, charged to the prepaid balance immediately. It comes back
+`provisioning`; poll `get()` until it is `ready`, usually a couple of minutes:
+
+```python
+from fxsocket import InsufficientBalanceError, PrivateServerStatus, ServerLimitError
+
+try:
+    server = fx.private_servers.create(slots=2, region="fra1", name="prop-guard")
+except InsufficientBalanceError as err:
+    print(f"Top up {err.shortfall_eur} EUR first")
+except ServerLimitError:
+    print(f"Already own the maximum ({options.max_servers})")
+
+while server.status != PrivateServerStatus.READY:
+    time.sleep(10)
+    server = fx.private_servers.get(server)
+```
+
+`resize()` changes the slot count. Increases are prorated over the rest of the
+period and charged now (the renewal date doesn't move); decreases are free and
+apply at the next renewal, so paid-for capacity is never destroyed mid-month.
+Shrinking below the accounts already on the server raises
+`AccountsExceedTargetError` — remove accounts first:
+
+```python
+server = fx.private_servers.resize(server, slots=4)
+```
+
+`cancel()` stops the server renewing: it runs until `period_end`, then expires.
+`resume()` undoes that while the period lasts (afterwards the machine is gone
+and `AlreadyLapsedError` is raised). `delete()` destroys the machine and every
+account on it right away, with **no refund** for the rest of the prepaid month —
+prefer `cancel()` unless you really want it gone now:
+
+```python
+server = fx.private_servers.cancel(server)      # stop at period_end
+assert server.cancel_at_period_end
+server = fx.private_servers.resume(server)      # changed your mind
+fx.private_servers.delete(server)               # irreversible, no refund
+```
+
+All of these move the prepaid balance, so they only work on balance-funded
+servers — a card- or crypto-funded one raises `NotBalanceFundedError` (a
+`ForbiddenError` subclass) and is managed from the dashboard. Read-only
+`fxs_ro_…` keys get a plain `ForbiddenError`.
 
 ## Wallet
 
@@ -483,7 +547,8 @@ if not wallet.covers_upcoming:
 Affordability is cumulative — with 24 EUR and three 12 EUR renewals the
 first two are covered and the third is not — so `shortfall_eur` is the
 total gap, not the size of any single charge. Topping up happens in the
-dashboard; the SDK deliberately exposes no payment operations.
+dashboard; the balance is only ever *spent* through the SDK (account seats
+and `private_servers.create()` / `resize()`), never topped up.
 
 ## Timestamps
 

{fxsocket-0.6.0 → fxsocket-0.8.0}/README.md

@@ -205,8 +205,11 @@ in `order_modify`, a literal `stop_loss=0.0` would *remove* your stop-loss, so
 it's rejected — pass `clear_stop_loss=True` to remove one deliberately, while
 `None` (the default) keeps the current value.
 
-MT4 and MT5 share one interface. MT5-only timeframes (`M2`, `M3`, `H2`, `H6`,
-`H8`, `H12`) raise `UnsupportedOnPlatformError` on MT4 before any request.
+MT4 and MT5 share one interface, timeframes included. Both accept the same nine:
+`M1`, `M5`, `M15`, `M30`, `H1`, `H4`, `D1`, `W1`, `MN1` (or `1min`, `5min`,
+`15min`, `30min`, `1h`, `4h`, `1d`, `1w`, `1month`). MT5's other periods, such
+as `H2` or `H12`, aren't served by the terminal API, so anything else raises
+`ValidationError` before any request.
 
 > **MT4 history note:** on MT4, `price_history` with `from_`/`to` bounds (or the
 > `D1` timeframe) can fail server-side with `CopyRates failed` when the terminal
@@ -416,7 +419,8 @@ with Client(api_key="fxs_live_...", verify_terminal_tls=False) as fx:
             server, server="ICMarkets-Demo", login=1150125, password="..."
         )
     except SlotsFullError as err:
-        print(f"Server full ({err.used}/{err.cap}) — raise the limit in the dashboard.")
+        print(f"Server full ({err.used}/{err.cap})")
+        server = fx.private_servers.resize(server, slots=err.cap + 1)
 
     # Poll until the on-server agent has the terminal up, then trade as usual.
     while True:
@@ -433,8 +437,68 @@ Accounts on a private server are traded and streamed exactly like
 shared-cluster accounts — their `rest_url` / `ws_url` simply point at the
 server's dedicated IP. The server presents a self-signed certificate, so reach
 it with `Client(..., verify_terminal_tls=False)` (or supply a pinned CA).
-*Purchasing* a server, canceling, and slot changes happen in the dashboard;
-the API deliberately exposes no billing operations.
+
+`server.cancel_at_period_end` is `True` once a server has been told to stop
+instead of renewing; it then runs until `server.period_end` and expires.
+
+### Buying, resizing and canceling
+
+`fx.private_servers.regions()` returns where servers may run, how big they may
+be and what that costs — call it before buying rather than hardcoding slugs:
+
+```python
+options = fx.private_servers.regions()
+if options.enabled:
+    print(options.region_codes)                     # ['fra1', 'lon1', ...]
+    print(options.max_slots, options.max_servers)
+    print(options.monthly_price_eur(3))             # Decimal('45') — 3 slots/month
+```
+
+`create()` buys one, charged to the prepaid balance immediately. It comes back
+`provisioning`; poll `get()` until it is `ready`, usually a couple of minutes:
+
+```python
+from fxsocket import InsufficientBalanceError, PrivateServerStatus, ServerLimitError
+
+try:
+    server = fx.private_servers.create(slots=2, region="fra1", name="prop-guard")
+except InsufficientBalanceError as err:
+    print(f"Top up {err.shortfall_eur} EUR first")
+except ServerLimitError:
+    print(f"Already own the maximum ({options.max_servers})")
+
+while server.status != PrivateServerStatus.READY:
+    time.sleep(10)
+    server = fx.private_servers.get(server)
+```
+
+`resize()` changes the slot count. Increases are prorated over the rest of the
+period and charged now (the renewal date doesn't move); decreases are free and
+apply at the next renewal, so paid-for capacity is never destroyed mid-month.
+Shrinking below the accounts already on the server raises
+`AccountsExceedTargetError` — remove accounts first:
+
+```python
+server = fx.private_servers.resize(server, slots=4)
+```
+
+`cancel()` stops the server renewing: it runs until `period_end`, then expires.
+`resume()` undoes that while the period lasts (afterwards the machine is gone
+and `AlreadyLapsedError` is raised). `delete()` destroys the machine and every
+account on it right away, with **no refund** for the rest of the prepaid month —
+prefer `cancel()` unless you really want it gone now:
+
+```python
+server = fx.private_servers.cancel(server)      # stop at period_end
+assert server.cancel_at_period_end
+server = fx.private_servers.resume(server)      # changed your mind
+fx.private_servers.delete(server)               # irreversible, no refund
+```
+
+All of these move the prepaid balance, so they only work on balance-funded
+servers — a card- or crypto-funded one raises `NotBalanceFundedError` (a
+`ForbiddenError` subclass) and is managed from the dashboard. Read-only
+`fxs_ro_…` keys get a plain `ForbiddenError`.
 
 ## Wallet
 
@@ -456,7 +520,8 @@ if not wallet.covers_upcoming:
 Affordability is cumulative — with 24 EUR and three 12 EUR renewals the
 first two are covered and the third is not — so `shortfall_eur` is the
 total gap, not the size of any single charge. Topping up happens in the
-dashboard; the SDK deliberately exposes no payment operations.
+dashboard; the balance is only ever *spent* through the SDK (account seats
+and `private_servers.create()` / `resize()`), never topped up.
 
 ## Timestamps
 

{fxsocket-0.6.0 → fxsocket-0.8.0}/src/fxsocket/__init__.py

@@ -30,6 +30,8 @@ from .enums import (
 )
 from .errors import (
     AccountCapError,
+    AccountsExceedTargetError,
+    AlreadyLapsedError,
     AuthError,
     ConnectFailedError,
     DuplicateAccountError,
@@ -38,10 +40,12 @@ from .errors import (
     IdempotencyError,
     InsufficientBalanceError,
     NoSubscriptionError,
+    NotBalanceFundedError,
     NotFoundError,
     PaymentRequiredError,
     RateLimitError,
     SeatLapsedError,
+    ServerLimitError,
     SlotsFullError,
     StreamError,
     TerminalNotReadyError,
@@ -78,9 +82,11 @@ from .models import (
     PositionTrade,
     PrivateServer,
     PrivateServerAccount,
+    PrivateServerOptions,
     ProfitCalc,
     Quote,
     ReadOnlyKey,
+    Region,
     ScopedAccount,
     ServerTimezone,
     SymbolInfo,
@@ -137,6 +143,8 @@ __all__ = [
     "Account",
     "PrivateServer",
     "PrivateServerAccount",
+    "PrivateServerOptions",
+    "Region",
     "ReadOnlyKey",
     "ScopedAccount",
     "OrderDefaults",
@@ -203,6 +211,10 @@ __all__ = [
     "SeatLapsedError",
     "DuplicateAccountError",
     "SlotsFullError",
+    "ServerLimitError",
+    "AccountsExceedTargetError",
+    "AlreadyLapsedError",
+    "NotBalanceFundedError",
     "IdempotencyError",
     "ConnectFailedError",
     "TerminalNotReadyError",

fxsocket-0.8.0/src/fxsocket/_version.py

@@ -0,0 +1 @@
+__version__ = "0.8.0"

{fxsocket-0.6.0 → fxsocket-0.8.0}/src/fxsocket/enums.py

@@ -229,35 +229,23 @@ class HealthStatus(str, Enum):
 class Timeframe(str, Enum):
     """Candle timeframes.
 
-    The MT5-only members (``M2``, ``M3``, ``H2``, ``H6``, ``H8``, ``H12``)
-    are rejected client-side for MT4 accounts.
+    Exactly the nine the terminal API accepts, on MT4 and MT5 alike (REST
+    ``price_history`` and the ``bars`` stream). MT5's other native periods
+    (``M2``, ``H2``, ``H12`` …) are not exposed by the terminal API, so they
+    are not members.
     """
 
     M1 = "M1"
-    M2 = "M2"
-    M3 = "M3"
     M5 = "M5"
     M15 = "M15"
     M30 = "M30"
     H1 = "H1"
-    H2 = "H2"
     H4 = "H4"
-    H6 = "H6"
-    H8 = "H8"
-    H12 = "H12"
     D1 = "D1"
     W1 = "W1"
     MN1 = "MN1"
 
 
-#: Timeframes that only MT5 supports.
-MT5_ONLY_TIMEFRAMES = frozenset(
-    {
-        Timeframe.M2,
-        Timeframe.M3,
-        Timeframe.H2,
-        Timeframe.H6,
-        Timeframe.H8,
-        Timeframe.H12,
-    }
-)
+#: Deprecated, always empty: both platforms accept every :class:`Timeframe`.
+#: Kept so existing imports don't break; will be removed in 1.0.
+MT5_ONLY_TIMEFRAMES: frozenset[Timeframe] = frozenset()

{fxsocket-0.6.0 → fxsocket-0.8.0}/src/fxsocket/errors.py

@@ -38,7 +38,15 @@ class AuthError(FxSocketError):
 class ForbiddenError(FxSocketError):
     """The key is valid but may not do this (HTTP 403) — typically a
     read-only ``fxs_ro_…`` key on an endpoint that mutates state, such as
-    multi-account trading."""
+    multi-account trading.
+
+    Base class for :class:`NotBalanceFundedError`."""
+
+
+class NotBalanceFundedError(ForbiddenError):
+    """This private server is not paid from the prepaid balance (HTTP 403
+    ``not_balance_funded``). Card- and crypto-funded servers are resized
+    and canceled in the dashboard, since the API only moves balance."""
 
 
 class RateLimitError(FxSocketError):
@@ -128,7 +136,7 @@ class DuplicateAccountError(FxSocketError):
 
 class SlotsFullError(FxSocketError):
     """Every purchased slot on the private server is taken (HTTP 409
-    ``slots_full``). Raise the server's limit from the dashboard."""
+    ``slots_full``). Buy more with ``client.private_servers.resize()``."""
 
     def __init__(
         self,
@@ -143,6 +151,24 @@ class SlotsFullError(FxSocketError):
         self.cap = cap
 
 
+class ServerLimitError(FxSocketError):
+    """You already own as many private servers as you may (HTTP 409
+    ``server_limit_reached``) — see ``max_servers`` on
+    :class:`~fxsocket.PrivateServerOptions`."""
+
+
+class AccountsExceedTargetError(FxSocketError):
+    """The server holds more accounts than the requested slot count allows
+    (HTTP 409 ``accounts_exceed_target``). Remove accounts first, then
+    resize."""
+
+
+class AlreadyLapsedError(FxSocketError):
+    """The paid period has already run out, so the cancellation can no
+    longer be undone (HTTP 409 ``already_lapsed``) — the machine is gone;
+    buy a new server."""
+
+
 class IdempotencyError(FxSocketError):
     """A multi-account batch was refused because of its ``Idempotency-Key``.
 
@@ -180,8 +206,9 @@ class TerminalTimeoutError(FxSocketError):
 class UnsupportedOnPlatformError(FxSocketError):
     """A requested feature doesn't exist on the account's platform.
 
-    Enforced client-side — e.g. stop-limit orders or MT5-only timeframes on
-    an MT4 account.
+    Nothing raises it at the moment: the MT4 and MT5 terminal APIs accept the
+    same timeframes and order operations. It stays exported for platform gaps
+    that need a client-side guard later.
     """
 
 
@@ -228,6 +255,8 @@ def error_from_response(resp: httpx.Response) -> FxSocketError:
     if status == 401:
         return AuthError(message, **common)
     if status == 403:
+        if code == "not_balance_funded":
+            return NotBalanceFundedError(message, **common)
         return ForbiddenError(message, **common)
     if code in _IDEMPOTENCY_CODES:
         return IdempotencyError(message, **common)
@@ -247,6 +276,12 @@ def error_from_response(resp: httpx.Response) -> FxSocketError:
             return SlotsFullError(
                 message, used=body.get("used"), cap=body.get("cap"), **common
             )
+        if code == "server_limit_reached":
+            return ServerLimitError(message, **common)
+        if code == "accounts_exceed_target":
+            return AccountsExceedTargetError(message, **common)
+        if code == "already_lapsed":
+            return AlreadyLapsedError(message, **common)
         return DuplicateAccountError(message, **common)
     if status == 402:
         fields: dict[str, Any] = body if isinstance(body, dict) else {}

{fxsocket-0.6.0 → fxsocket-0.8.0}/src/fxsocket/management.py

@@ -18,6 +18,7 @@ from .models import (
     Account,
     PrivateServer,
     PrivateServerAccount,
+    PrivateServerOptions,
     ReadOnlyKey,
     Wallet,
 )
@@ -249,11 +250,22 @@ def _private_account_payload(
     }
 
 
+def _private_server_payload(*, slots: int, region: str, name: str) -> dict[str, object]:
+    body: dict[str, object] = {"slots": slots, "region": region}
+    if name:
+        body["name"] = name
+    return body
+
+
 class PrivateServers:
     """Synchronous private-server operations.
 
-    Read + on-server account management only: purchasing a server,
-    canceling, and slot changes happen in the dashboard.
+    Covers the whole lifecycle: :meth:`regions` to see what can be bought,
+    :meth:`create` to buy one from the prepaid balance, :meth:`resize`,
+    :meth:`cancel` / :meth:`resume`, :meth:`delete`, and
+    :meth:`add_account` / :meth:`remove_account` for the accounts on it.
+    Balance is the only payment method here — card and crypto purchases
+    need a checkout redirect, so those stay in the dashboard.
     """
 
     def __init__(self, http: SyncHTTP) -> None:
@@ -264,6 +276,15 @@ class PrivateServers:
         data = self._http.request("GET", "/private-servers")
         return [PrivateServer.model_validate(row) for row in data]
 
+    def regions(self) -> PrivateServerOptions:
+        """Where private servers may run, how big they may be, what it costs.
+
+        Returns the whole options payload, not just the region list — see
+        :class:`~fxsocket.PrivateServerOptions`.
+        """
+        data = self._http.request("GET", "/private-servers/regions")
+        return PrivateServerOptions.model_validate(data)
+
     def get(self, server: PrivateServer | str) -> PrivateServer:
         """Fetch one server by id (use this to poll account readiness)."""
         data = self._http.request(
@@ -271,6 +292,89 @@ class PrivateServers:
         )
         return PrivateServer.model_validate(data)
 
+    def create(self, *, slots: int, region: str, name: str = "") -> PrivateServer:
+        """Buy a dedicated server, charged to the prepaid balance now.
+
+        ``region`` must be one of the ``code`` values from :meth:`regions`,
+        ``slots`` how many accounts it should hold (priced
+        ``first_slot + additional_slot * (slots - 1)`` per month, billed
+        again every month until you :meth:`cancel` it) and ``name`` an
+        optional label for your own reference.
+
+        Comes back already ``provisioning`` — poll :meth:`get` until
+        ``status`` is ``ready``, usually a couple of minutes. Raises
+        :class:`~fxsocket.InsufficientBalanceError` when the balance does
+        not cover it, :class:`~fxsocket.ServerLimitError` when you already
+        own the maximum, and :class:`~fxsocket.ForbiddenError` when private
+        hosting is off for the deployment or the key is read-only.
+        """
+        data = self._http.request(
+            "POST",
+            "/private-servers",
+            json=_private_server_payload(slots=slots, region=region, name=name),
+        )
+        return PrivateServer.model_validate(data)
+
+    def resize(self, server: PrivateServer | str, *, slots: int) -> PrivateServer:
+        """Change how many accounts the server may hold.
+
+        Increases are prorated over what is left of the current period and
+        charged to the balance immediately; the renewal date does not move.
+        Decreases are free and take effect at the next renewal, so capacity
+        already paid for is never destroyed mid-period.
+
+        Raises :class:`~fxsocket.AccountsExceedTargetError` when more
+        accounts are on the server than the new limit allows (remove some
+        first), :class:`~fxsocket.InsufficientBalanceError` when the
+        balance does not cover a prorated increase, and
+        :class:`~fxsocket.NotBalanceFundedError` for card- or
+        crypto-funded servers.
+        """
+        data = self._http.request(
+            "PATCH",
+            f"/private-servers/{private_server_id_of(server)}",
+            json={"slots": slots},
+        )
+        return PrivateServer.model_validate(data)
+
+    def delete(self, server: PrivateServer | str) -> None:
+        """Destroy the machine and everything on it — irreversible.
+
+        The droplet is torn down, its IP released and every account hosted
+        on it removed. There is **no refund**: whatever is left of the
+        prepaid month is forfeited. To stop paying without losing the rest
+        of the period, use :meth:`cancel` instead.
+        """
+        self._http.request("DELETE", f"/private-servers/{private_server_id_of(server)}")
+
+    def cancel(self, server: PrivateServer | str) -> PrivateServer:
+        """Stop the server renewing, letting the paid period run out.
+
+        It keeps running until ``period_end``, then expires; nothing is
+        refunded and nothing is charged again. Prefer this to
+        :meth:`delete`, which forfeits the rest of the month. Reversible
+        with :meth:`resume` while the period lasts. Raises
+        :class:`~fxsocket.NotBalanceFundedError` for card- or
+        crypto-funded servers.
+        """
+        data = self._http.request(
+            "POST", f"/private-servers/{private_server_id_of(server)}/cancel"
+        )
+        return PrivateServer.model_validate(data)
+
+    def resume(self, server: PrivateServer | str) -> PrivateServer:
+        """Undo a :meth:`cancel`, so the server renews from the balance
+        again at the end of the current period.
+
+        Only works while it is still running: raises
+        :class:`~fxsocket.AlreadyLapsedError` once the paid period has
+        lapsed and the machine is gone — buy a new one with :meth:`create`.
+        """
+        data = self._http.request(
+            "DELETE", f"/private-servers/{private_server_id_of(server)}/cancel"
+        )
+        return PrivateServer.model_validate(data)
+
     def add_account(
         self,
         private_server: PrivateServer | str,
@@ -325,12 +429,49 @@ class AsyncPrivateServers:
         data = await self._http.request("GET", "/private-servers")
         return [PrivateServer.model_validate(row) for row in data]
 
+    async def regions(self) -> PrivateServerOptions:
+        data = await self._http.request("GET", "/private-servers/regions")
+        return PrivateServerOptions.model_validate(data)
+
     async def get(self, server: PrivateServer | str) -> PrivateServer:
         data = await self._http.request(
             "GET", f"/private-servers/{private_server_id_of(server)}"
         )
         return PrivateServer.model_validate(data)
 
+    async def create(self, *, slots: int, region: str, name: str = "") -> PrivateServer:
+        data = await self._http.request(
+            "POST",
+            "/private-servers",
+            json=_private_server_payload(slots=slots, region=region, name=name),
+        )
+        return PrivateServer.model_validate(data)
+
+    async def resize(self, server: PrivateServer | str, *, slots: int) -> PrivateServer:
+        data = await self._http.request(
+            "PATCH",
+            f"/private-servers/{private_server_id_of(server)}",
+            json={"slots": slots},
+        )
+        return PrivateServer.model_validate(data)
+
+    async def delete(self, server: PrivateServer | str) -> None:
+        await self._http.request(
+            "DELETE", f"/private-servers/{private_server_id_of(server)}"
+        )
+
+    async def cancel(self, server: PrivateServer | str) -> PrivateServer:
+        data = await self._http.request(
+            "POST", f"/private-servers/{private_server_id_of(server)}/cancel"
+        )
+        return PrivateServer.model_validate(data)
+
+    async def resume(self, server: PrivateServer | str) -> PrivateServer:
+        data = await self._http.request(
+            "DELETE", f"/private-servers/{private_server_id_of(server)}/cancel"
+        )
+        return PrivateServer.model_validate(data)
+
     async def add_account(
         self,
         private_server: PrivateServer | str,