Python SDK

pip install hypermid

from hypermid import Hypermid, HypermidConfig

# Anonymous tier — works immediately, no signup
hm = Hypermid()

# With a partner API key
hm = Hypermid(HypermidConfig(api_key="your-api-key"))

# Full custom config
hm = Hypermid(HypermidConfig(
    api_key="your-api-key",
    base_url="https://api.hypermid.io",  # optional, default shown
    timeout=30.0,                         # optional, seconds, default shown
))

# Sync — for scripts, Django views, Flask, FastAPI sync endpoints
from hypermid import Hypermid

hm = Hypermid()
chains = hm.get_chains()
hm.close()  # release connection pool

# Async — for FastAPI async endpoints, asyncio scripts, Trio
import asyncio
from hypermid import AsyncHypermid

async def main():
    async with AsyncHypermid() as hm:
        chains = await hm.get_chains()

asyncio.run(main())

with Hypermid() as hm:
    chains = hm.get_chains()
# pool released here

chains = hm.get_chains()

tokens = hm.get_tokens(
    chains="1,42161,137",
    keywords="usdc",
)

quote = hm.get_quote(
    from_chain=1,
    from_token="0x0000000000000000000000000000000000000000",
    from_amount="1000000000000000000",  # base units (wei)
    to_chain=42161,
    to_token="0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
    from_address="0xYourAddress",
)

exec = hm.execute(
    from_chain=1,
    from_token="0x0000000000000000000000000000000000000000",
    from_amount="1000000000000000000",
    to_chain=42161,
    to_token="0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
    from_address="0xYourAddress",
    to_address="0xYourAddress",
)

# EVM swaps return a transaction_request to sign and broadcast.
# Non-EVM (NEAR Intents) return a deposit_address to send tokens to.

status = hm.get_status(
    tx_hash="0xTxHash",
    from_chain=1,
    to_chain=42161,
)

balances = hm.get_balances(
    address="0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
    chain_ids=[1, 42161, 137],  # optional — restrict EVM coverage
)

print(f"Total: ${balances.total_balance_usd} across {len(balances.balances)} chains")

status = hm.get_deposit_status(
    deposit_address=exec.deposit_address,
)

if status.status == "completed":
    print("Funds delivered")

created = hm.create_webhook(
    url="https://yourapp.com/webhooks",
    events=["swap.completed", "swap.failed", "onramp.completed"],
)
print("Webhook secret (store it):", created.secret)

from hypermid import verify_webhook_signature

ok = verify_webhook_signature(
    body=request.body,
    signature=request.headers["X-Hypermid-Signature"],
    secret=os.environ["HYPERMID_WEBHOOK_SECRET"],
)
if not ok:
    return Response(status_code=401)

quote = hm.get_onramp_quote(
    fiat_currency="USD",
    crypto_asset="ETH",
    chain_id=1,
    fiat_amount=100,
    payment_method="credit_card",
    wallet_address="0xYourAddress",
)

checkout = hm.get_onramp_checkout(
    fiat_currency="USD",
    crypto_asset="ETH",
    chain_id=1,
    fiat_amount=100,
    payment_method="credit_card",
    wallet_address="0xYourAddress",
    redirect_url="https://yourapp.com/callback",
)
print("Send user to:", checkout.checkout_url)

status = hm.get_onramp_status("ord_abc123")

res = hm.register_inbound_receiver(
    tx_hash="0xDepositTxHash",
    from_address="0xSender",
    to_address="0xPulseChainRecipient",
    output_token="0xOutputTokenOnPulse",
    destination_domain=369,
    signature="0xEIP712Signature",
)

from hypermid import (
    HypermidError,
    HypermidTimeoutError,
    HypermidNetworkError,
)

try:
    quote = hm.get_quote(...)
except HypermidError as e:
    print(f"API error {e.status}: [{e.code}] {e.message}")
    print(f"Request ID: {e.request_id}")
except HypermidTimeoutError as e:
    print(f"Request timed out after {e.timeout_seconds}s")
except HypermidNetworkError as e:
    print(f"Network error: {e}")

from hypermid.types import (
    ChainsResponse,
    TokensResponse,
    QuoteResponse,
    ExecuteResponse,
    StatusResponse,
    DepositStatusResponse,
    BalancesResponse,
    TokenBalance,
    CreateWebhookResponse,
    OnrampQuoteResponse,
    OnrampCheckoutResponse,
    OnrampStatusResponse,
    InboundReceiverResponse,
)

from hypermid import Hypermid

with Hypermid() as hm:
    # 1. Quote
    quote = hm.get_quote(
        from_chain=1,
        from_token="0x0000000000000000000000000000000000000000",
        from_amount="1000000000000000000",
        to_chain=42161,
        to_token="0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
        from_address="0xYourAddress",
    )
    print(f"Provider: {quote.provider} | feeBps: {quote.fee_bps}")

    # 2. Execute (returns the tx to sign)
    exec = hm.execute(
        from_chain=1,
        from_token="0x0000000000000000000000000000000000000000",
        from_amount="1000000000000000000",
        to_chain=42161,
        to_token="0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
        from_address="0xYourAddress",
        to_address="0xYourAddress",
    )

    # Sign and broadcast exec.transaction_request via your wallet,
    # then poll status with the resulting tx hash:
    # status = hm.get_status(tx_hash="0x...", from_chain=1, to_chain=42161)

import asyncio
from hypermid import AsyncHypermid

async def main():
    async with AsyncHypermid() as hm:
        quote = await hm.get_quote(
            from_chain=1,
            from_token="0x0000000000000000000000000000000000000000",
            from_amount="1000000000000000000",
            to_chain=42161,
            to_token="0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
            from_address="0xYourAddress",
        )
        print(quote.provider)

asyncio.run(main())