limitguard

Official Python SDK for the LimitGuard Trust Intelligence API: entity verification and risk scoring for EU businesses, paid per call in USDC over x402 or debited from an API key's prepaid balance.

Install

pip install limitguard

With wallet support, for agents that pay per call:

pip install 'limitguard[solana]'   # Solana USDC
pip install 'limitguard[evm]'      # Base USDC

Python 3.10 or newer.

Quickstart

import asyncio
from limitguard import LimitGuardClient


async def main():
    async with LimitGuardClient(api_key="lg_live_...") as client:
        result = await client.check_entity("Acme BV", country="NL")
        print(result.trust_score, result.trust_level, result.recommendation)


asyncio.run(main())

check_entity returns a TrustResponse (trust_score 0-100, trust_level, cluster, recommendation, confidence, top_factors). risk_score is the cheaper two-source variant and returns a RiskResponse.

Paying for calls

Two ways to satisfy the API's per-call price, and the client accepts either or both:

A free-tier key identifies you and tracks usage; it holds no balance and does not pay for calls. On its own it will raise PaymentRequiredError on any paid endpoint. Add a wallet, or top up the key (POST /v1/keys/upgrade/{tier} or POST /v1/keys/topup/{usd} via x402).

Wallet example (Solana, needs the [solana] extra and a wallet holding USDC — no SOL: LimitGuard's fee payer co-signs the transaction and covers the network fee. Pass broadcast=True to SolanaWallet to pay it yourself instead, which requires SOL):

from solders.keypair import Keypair
from limitguard import LimitGuardClient
from limitguard.x402 import SolanaWallet

wallet = SolanaWallet(keypair=Keypair.from_base58_string(private_key))
async with LimitGuardClient(wallet=wallet) as client:
    result = await client.check_entity("Acme BV", country="NL")

SolanaWallet pays in Solana USDC and EvmWallet in Base USDC; both take the key of the wallet the money leaves.

When the API quotes a settled-transfer price, the client also signs a short challenge message with the same wallet that sent the USDC and puts it in X-Payment-Challenge-Signature. The message is the protocol tag, the resource path, the chain id, your transaction hash or signature, and the challenge id — five lines, exactly as documented on the x402 protocol page. It exists because a transaction hash is public the moment it lands: without the signature, anyone who saw it could redeem your payment. Your private key never leaves the wallet object, and a wallet that cannot sign still pays — the field is optional server-side today and will become required, so signing now means nothing breaks later.

A complete agent is in examples/agent_with_wallet.py, included in the source distribution (pip download --no-binary :all: limitguard).

Errors

All exceptions subclass LimitGuardError: AuthenticationError, PaymentRequiredError, RateLimitError, ValidationError, ServerError. The client retries 429 and 5xx responses with backoff before raising.

Links

• Documentation: https://docs.limitguard.ai
• Quickstart and a free sandbox key (mock data, no wallet): https://api.limitguard.ai/v1/quickstart
• x402 protocol: https://docs.limitguard.ai/x402-protocol
• Issues and support: https://github.com/jwconsultancyteam/limitguard-mcp/issues

Version

import limitguard
print(limitguard.__version__)

Releases are tagged sdk-v<version> and published to PyPI from that tag.