Overview The Devdraft Python SDK provides a complete client library for integrating payment processing, customer management, and webhook functionality into your Python applications.
Pythonic API Follows Python conventions with snake_case naming and type hints
Context Manager Support Clean resource management with Python’s with statement
Comprehensive Access to all Devdraft API endpoints and features
Easy Integration Simple configuration and intuitive method names
Installation Requirements Quick Start import devdraft import os # Configure the SDK configuration = devdraft.Configuration( host = "https://api.devdraft.ai" ) configuration.api_key[ 'x-client-key' ] = os.environ.get( 'DEVDRAFT_CLIENT_KEY' ) configuration.api_key[ 'x-client-secret' ] = os.environ.get( 'DEVDRAFT_CLIENT_SECRET' ) # Use context manager for automatic resource cleanup with devdraft.ApiClient(configuration) as api_client: # Initialize API instances transfers_api = devdraft.TransfersApi(api_client) webhooks_api = devdraft.WebhooksApi(api_client) # Use the APIs transfer = transfers_api.transfer_controller_create_direct_wallet_transfer( devdraft.CreateDirectWalletTransferDto( wallet_id = 'your-wallet-id' , network = 'solana' , stable_coin_currency = 'usdc' , amount = 100.00 ) )
API Classes The SDK is organized into API classes, each handling a specific domain:
API Class Description APIHealthApi Service health checks and status monitoring AppBalancesApi Query application balances across stablecoins CustomersApi Customer management and KYC operations ExchangeRatesApi Real-time currency exchange rates InvoicesApi Invoice creation and management LiquidationAddressesApi Cryptocurrency liquidation addresses PaymentIntentsApi Payment intent creation for bank and stablecoin PaymentLinksApi Generate and manage payment links ProductsApi Product catalog management TaxesApi Tax configuration and management TestPaymentsApi Test payment processing in sandbox TransfersApi Initiate and manage fund transfers WalletsApi Wallet management and balances WebhooksApi Webhook configuration and management
API Health Monitor service health and availability.
Methods health_controller_check_v0()Authenticated health check endpoint requiring API credentials.
import devdraft with devdraft.ApiClient(configuration) as api_client: health_api = devdraft.APIHealthApi(api_client) try : health_api.health_controller_check_v0() print ( 'Service is healthy and authenticated' ) except devdraft.ApiException as e: print ( f 'Health check failed: { e } ' )
Returns: Nonehealth_controller_public_health_check_v0()Public health check endpoint (no authentication required).
status = health_api.health_controller_public_health_check_v0() print ( f 'Service status: { status } ' )
Returns: PublicHealthResponseDtoApp Balances Query your application’s stablecoin balances.
Methods balance_controller_get_all_balances()Get all stablecoin balances for your application.
import devdraft with devdraft.ApiClient(configuration) as api_client: balances_api = devdraft.AppBalancesApi(api_client) balances = balances_api.balance_controller_get_all_balances() print ( f 'USDC Balance: { balances.usdc } ' ) print ( f 'EURC Balance: { balances.eurc } ' )
Returns: AllBalancesResponsebalance_controller_get_usdc_balance()Get USDC balance only.
usdc_balance = balances_api.balance_controller_get_usdc_balance() print ( f 'USDC: { usdc_balance.amount } ' )
Returns: AggregatedBalanceResponsebalance_controller_get_eurc_balance()Get EURC balance only.
eurc_balance = balances_api.balance_controller_get_eurc_balance() print ( f 'EURC: { eurc_balance.amount } ' )
Returns: AggregatedBalanceResponseCustomers Manage customer records and KYC information.
Methods customer_controller_create(create_customer_dto)Create a new customer.
import devdraft from devdraft.model.create_customer_dto import CreateCustomerDto with devdraft.ApiClient(configuration) as api_client: customers_api = devdraft.CustomersApi(api_client) new_customer = customers_api.customer_controller_create( CreateCustomerDto( first_name = 'John' , last_name = 'Doe' , email = 'john.doe@example.com' , type = 'INDIVIDUAL' , country = 'US' ) ) print ( f 'Customer created: { new_customer.id } ' )
Parameters:
create_customer_dto: CreateCustomerDto - Customer details
Returns: Customercustomer_controller_find_all(**kwargs)Get all customers with optional filters.
customers = customers_api.customer_controller_find_all( page = 1 , limit = 20 , status = 'ACTIVE' ) for customer in customers: print ( f ' { customer.first_name } { customer.last_name } - { customer.email } ' )
Parameters:
page: int - Page number (optional, default: 1)limit: int - Items per page (optional, default: 20)status: str - Filter by status (optional)
Returns: List[Customer]customer_controller_find_one(id)Get a customer by ID.
customer = customers_api.customer_controller_find_one( id = 'customer-id-here' ) print ( f 'Customer: { customer.first_name } { customer.last_name } ' )
Parameters: Returns: Customercustomer_controller_update(id, update_customer_dto)Update a customer’s information.
from devdraft.model.update_customer_dto import UpdateCustomerDto updated = customers_api.customer_controller_update( id = 'customer-id-here' , update_customer_dto = UpdateCustomerDto( phone = '+1234567890' , address = '123 Main St' ) ) print ( f 'Customer updated: { updated.id } ' )
Parameters:
id: str - Customer IDupdate_customer_dto: UpdateCustomerDto - Fields to update
Returns: CustomerExchange Rates Get real-time currency exchange rates.
Methods exchange_rate_controller_get_exchange_rate(**kwargs)Get exchange rate between any two supported currencies.
import devdraft with devdraft.ApiClient(configuration) as api_client: rates_api = devdraft.ExchangeRatesApi(api_client) rate = rates_api.exchange_rate_controller_get_exchange_rate( var_from = 'USD' , to = 'EUR' ) print ( f '1 USD = { rate.rate } EUR' ) print ( f 'Rate expires at: { rate.expires_at } ' )
Parameters:
var_from: str - Source currency codeto: str - Target currency code
Returns: ExchangeRateResponseDtoexchange_rate_controller_get_usdto_eur_rate()Get USD to EUR exchange rate.
usd_to_eur = rates_api.exchange_rate_controller_get_usdto_eur_rate() print ( f 'USD to EUR: { usd_to_eur.rate } ' )
Returns: ExchangeRateResponseDtoexchange_rate_controller_get_eurto_usd_rate()Get EUR to USD exchange rate.
eur_to_usd = rates_api.exchange_rate_controller_get_eurto_usd_rate() print ( f 'EUR to USD: { eur_to_usd.rate } ' )
Returns: ExchangeRateResponseDtoInvoices Create and manage invoices for your customers.
Methods invoice_controller_create(create_invoice_dto)Create a new invoice.
import devdraft from devdraft.model.create_invoice_dto import CreateInvoiceDto with devdraft.ApiClient(configuration) as api_client: invoices_api = devdraft.InvoicesApi(api_client) invoice = invoices_api.invoice_controller_create( CreateInvoiceDto( customer_id = 'customer-id' , items = [ { 'description' : 'Premium Subscription' , 'quantity' : 1 , 'price' : 99.99 , 'currency' : 'USD' } ], due_date = '2024-12-31' ) ) print ( f 'Invoice created: { invoice.id } ' ) print ( f 'Total: { invoice.total } ' )
Parameters:
create_invoice_dto: CreateInvoiceDto - Invoice details
Returns: Invoiceinvoice_controller_find_all(**kwargs)Get all invoices.
invoices = invoices_api.invoice_controller_find_all( page = 1 , limit = 50 , status = 'UNPAID' )
Parameters:
page: int - Page number (optional)limit: int - Items per page (optional)status: str - Filter by status (optional)
Returns: List[Invoice]invoice_controller_find_one(id)Get an invoice by ID.
invoice = invoices_api.invoice_controller_find_one( id = 'invoice-id' )
Parameters: Returns: Invoiceinvoice_controller_update(id, update_invoice_dto)Update an invoice.
from datetime import datetime updated = invoices_api.invoice_controller_update( id = 'invoice-id' , update_invoice_dto = { 'status' : 'PAID' , 'paid_at' : datetime.now().isoformat() } )
Parameters:
id: str - Invoice IDupdate_invoice_dto: dict - Fields to update
Returns: InvoiceLiquidation Addresses Manage cryptocurrency liquidation addresses for customers.
Methods liquidation_address_controller_create_liquidation_address(customer_id, create_liquidation_address_dto)Create a new liquidation address for a customer.
import devdraft from devdraft.model.create_liquidation_address_dto import CreateLiquidationAddressDto with devdraft.ApiClient(configuration) as api_client: liquidation_api = devdraft.LiquidationAddressesApi(api_client) address = liquidation_api.liquidation_address_controller_create_liquidation_address( customer_id = 'customer-id' , create_liquidation_address_dto = CreateLiquidationAddressDto( network = 'solana' , currency = 'usdc' ) ) print ( f 'Liquidation address: { address.address } ' ) print ( f 'Network: { address.network } ' )
Parameters:
customer_id: str - Customer IDcreate_liquidation_address_dto: CreateLiquidationAddressDto - Address details
Returns: LiquidationAddressResponseDtoliquidation_address_controller_get_liquidation_addresses(customer_id)Get all liquidation addresses for a customer.
addresses = liquidation_api.liquidation_address_controller_get_liquidation_addresses( customer_id = 'customer-id' ) for addr in addresses: print ( f ' { addr.network } : { addr.address } ' )
Parameters:
customer_id: str - Customer ID
Returns: List[LiquidationAddressResponseDto]liquidation_address_controller_get_liquidation_address(customer_id, liquidation_address_id)Get a specific liquidation address.
address = liquidation_api.liquidation_address_controller_get_liquidation_address( customer_id = 'customer-id' , liquidation_address_id = 'address-id' )
Parameters:
customer_id: str - Customer IDliquidation_address_id: str - Address ID
Returns: LiquidationAddressResponseDtoPayment Intents Create payment intents for bank and stablecoin payments.
Methods payment_intent_controller_create_bank_payment_intent(create_bank_payment_intent_dto)Create a bank payment intent.
import devdraft from devdraft.model.create_bank_payment_intent_dto import CreateBankPaymentIntentDto with devdraft.ApiClient(configuration) as api_client: intent_api = devdraft.PaymentIntentsApi(api_client) intent = intent_api.payment_intent_controller_create_bank_payment_intent( CreateBankPaymentIntentDto( customer_id = 'customer-id' , amount = 1000.00 , currency = 'USD' , payment_rail = 'wire' ) ) print ( f 'Payment intent: { intent.id } ' ) print ( f 'Status: { intent.status } ' )
Parameters:
create_bank_payment_intent_dto: CreateBankPaymentIntentDto - Intent details
Returns: PaymentIntentpayment_intent_controller_create_stable_payment_intent(create_stable_payment_intent_dto)Create a stablecoin payment intent.
from devdraft.model.create_stable_payment_intent_dto import CreateStablePaymentIntentDto stable_intent = intent_api.payment_intent_controller_create_stable_payment_intent( CreateStablePaymentIntentDto( customer_id = 'customer-id' , amount = 500.00 , currency = 'usdc' , network = 'solana' ) )
Parameters:
create_stable_payment_intent_dto: CreateStablePaymentIntentDto - Intent details
Returns: PaymentIntentPayment Links Generate and manage payment links for easy customer payments.
Methods payment_links_controller_create(create_payment_link_dto)Create a new payment link.
import devdraft from devdraft.model.create_payment_link_dto import CreatePaymentLinkDto with devdraft.ApiClient(configuration) as api_client: links_api = devdraft.PaymentLinksApi(api_client) link = links_api.payment_links_controller_create( CreatePaymentLinkDto( name = 'Product Purchase' , amount = 99.99 , currency = 'USD' , products = [ { 'name' : 'Premium Plan' , 'quantity' : 1 , 'price' : 99.99 } ] ) ) print ( f 'Payment link: { link.url } ' ) print ( f 'Share this link with customers: { link.short_url } ' )
Parameters:
create_payment_link_dto: CreatePaymentLinkDto - Link details
Returns: PaymentLinkpayment_links_controller_find_all(**kwargs)Get all payment links.
links = links_api.payment_links_controller_find_all( page = 1 , limit = 20 , active = True )
Parameters:
page: int - Page number (optional)limit: int - Items per page (optional)active: bool - Filter by active status (optional)
Returns: List[PaymentLink]payment_links_controller_find_one(id)Get a payment link by ID.
link = links_api.payment_links_controller_find_one( id = 'link-id' )
Parameters:
id: str - Payment link ID
Returns: PaymentLinkpayment_links_controller_update(id, update_payment_link_dto)Update a payment link.
updated = links_api.payment_links_controller_update( id = 'link-id' , update_payment_link_dto = { 'active' : False , 'expires_at' : '2024-12-31T23:59:59Z' } )
Parameters:
id: str - Payment link IDupdate_payment_link_dto: dict - Fields to update
Returns: PaymentLinkProducts Manage your product catalog.
Methods product_controller_create(create_product_dto)Create a new product.
import devdraft with devdraft.ApiClient(configuration) as api_client: products_api = devdraft.ProductsApi(api_client) product = products_api.product_controller_create( { 'name' : 'Premium Subscription' , 'description' : 'Access to all premium features' , 'price' : 99.99 , 'currency' : 'USD' , 'category' : 'subscriptions' } ) print ( f 'Product created: { product.id } ' )
Parameters:
create_product_dto: dict - Product details
Returns: Productproduct_controller_find_all(**kwargs)Get all products.
products = products_api.product_controller_find_all( category = 'subscriptions' , active = True )
Parameters:
category: str - Filter by category (optional)active: bool - Filter by active status (optional)
Returns: List[Product]product_controller_find_one(id)Get a product by ID.
product = products_api.product_controller_find_one( id = 'product-id' )
Parameters: Returns: Productproduct_controller_update(id, update_product_dto)Update a product.
updated = products_api.product_controller_update( id = 'product-id' , update_product_dto = { 'price' : 89.99 , 'description' : 'Updated description' } )
Parameters:
id: str - Product IDupdate_product_dto: dict - Fields to update
Returns: Productproduct_controller_remove(id)Delete a product.
products_api.product_controller_remove( id = 'product-id' )
Parameters: Returns: Noneproduct_controller_upload_image(id, images)Upload images for a product.
with open ( 'product-image.jpg' , 'rb' ) as image_file: products_api.product_controller_upload_image( id = 'product-id' , images = [image_file] )
Parameters:
id: str - Product IDimages: List[file] - Image files
Returns: ProductTaxes Configure and manage tax settings.
Methods tax_controller_create(create_tax_dto)Create a new tax configuration.
import devdraft from devdraft.model.create_tax_dto import CreateTaxDto with devdraft.ApiClient(configuration) as api_client: taxes_api = devdraft.TaxesApi(api_client) tax = taxes_api.tax_controller_create( CreateTaxDto( name = 'Sales Tax' , percentage = 8.5 , country = 'US' , state = 'CA' ) ) print ( f 'Tax created: { tax.id } ' )
Parameters:
create_tax_dto: CreateTaxDto - Tax details
Returns: Taxtax_controller_find_all(**kwargs)Get all tax configurations.
taxes = taxes_api.tax_controller_find_all( country = 'US' )
Parameters:
country: str - Filter by country (optional)
Returns: List[Tax]tax_controller_find_one(id)Get a tax configuration by ID.
tax = taxes_api.tax_controller_find_one( id = 'tax-id' )
Parameters: Returns: Taxtax_controller_update(id, update_tax_dto)Update a tax configuration.
from devdraft.model.update_tax_dto import UpdateTaxDto updated = taxes_api.tax_controller_update( id = 'tax-id' , update_tax_dto = UpdateTaxDto( percentage = 9.0 ) )
Parameters:
id: str - Tax IDupdate_tax_dto: UpdateTaxDto - Fields to update
Returns: Taxtax_controller_remove(id)Delete a tax configuration.
taxes_api.tax_controller_remove( id = 'tax-id' )
Parameters: Returns: NoneTest Payments Process test payments in sandbox environment.
Methods test_payment_controller_create_payment_v0(payment_request_dto)Create a test payment.
import devdraft from devdraft.model.payment_request_dto import PaymentRequestDto with devdraft.ApiClient(configuration) as api_client: test_api = devdraft.TestPaymentsApi(api_client) payment = test_api.test_payment_controller_create_payment_v0( PaymentRequestDto( amount = 100.00 , currency = 'USD' , customer_id = 'test-customer-id' , idempotency_key = 'unique-key-123' ) ) print ( f 'Test payment: { payment.id } ' ) print ( f 'Status: { payment.status } ' )
Parameters:
payment_request_dto: PaymentRequestDto - Payment details
Returns: PaymentResponseDtotest_payment_controller_get_payment_v0(id)Get test payment details by ID.
payment = test_api.test_payment_controller_get_payment_v0( id = 'payment-id' ) print ( f 'Payment status: { payment.status } ' )
Parameters: Returns: PaymentResponseDtotest_payment_controller_refund_payment_v0(id, **kwargs)Refund a test payment.
refund = test_api.test_payment_controller_refund_payment_v0( id = 'payment-id' , refund_amount = 50.00 ) print ( f 'Refund processed: { refund.id } ' )
Parameters:
id: str - Payment IDrefund_amount: float - Amount to refund (optional, defaults to full amount)
Returns: RefundResponseDtoTransfers Initiate and manage fund transfers between different payment rails.
Methods transfer_controller_create_direct_bank_transfer(create_direct_bank_transfer_dto)Create a direct bank transfer.
import devdraft from devdraft.model.create_direct_bank_transfer_dto import CreateDirectBankTransferDto with devdraft.ApiClient(configuration) as api_client: transfers_api = devdraft.TransfersApi(api_client) transfer = transfers_api.transfer_controller_create_direct_bank_transfer( CreateDirectBankTransferDto( wallet_id = 'wallet-id' , payment_rail = 'wire' , source_currency = 'usd' , destination_currency = 'usdc' , amount = 1000.00 ) ) print ( f 'Transfer created: { transfer.id } ' ) print ( f 'Bank instructions: { transfer.source_deposit_instructions } ' )
Parameters:
create_direct_bank_transfer_dto: CreateDirectBankTransferDto - Transfer details
Returns: TransferSee also: Direct Bank Transfer Guide transfer_controller_create_direct_wallet_transfer(create_direct_wallet_transfer_dto)Create a direct wallet transfer.
from devdraft.model.create_direct_wallet_transfer_dto import CreateDirectWalletTransferDto transfer = transfers_api.transfer_controller_create_direct_wallet_transfer( CreateDirectWalletTransferDto( wallet_id = 'wallet-id' , network = 'solana' , stable_coin_currency = 'usdc' , amount = 500.00 ) ) print ( f 'Transfer created: { transfer.id } ' ) print ( f 'Deposit address: { transfer.source_deposit_instructions.to_address } ' )
Parameters:
create_direct_wallet_transfer_dto: CreateDirectWalletTransferDto - Transfer details
Returns: TransferSee also: Direct Wallet Transfer Guide transfer_controller_create_external_bank_transfer(create_external_bank_transfer_dto)Create an external bank transfer (from your wallet to external bank).
from devdraft.model.create_external_bank_transfer_dto import CreateExternalBankTransferDto transfer = transfers_api.transfer_controller_create_external_bank_transfer( CreateExternalBankTransferDto( source_wallet_id = 'wallet-id' , destination_bank_account_id = 'bank-account-id' , amount = 1000.00 , currency = 'USD' ) )
Parameters:
create_external_bank_transfer_dto: CreateExternalBankTransferDto - Transfer details
Returns: Transfertransfer_controller_create_external_stablecoin_transfer(create_external_stablecoin_transfer_dto)Create an external stablecoin transfer (from your wallet to external wallet).
from devdraft.model.create_external_stablecoin_transfer_dto import CreateExternalStablecoinTransferDto transfer = transfers_api.transfer_controller_create_external_stablecoin_transfer( CreateExternalStablecoinTransferDto( source_wallet_id = 'wallet-id' , destination_address = '0x742d35Cc6Ff82a8C2D8D1Da9da17c7eDfD5bE0a3' , network = 'ethereum' , currency = 'usdc' , amount = 250.00 ) )
Parameters:
create_external_stablecoin_transfer_dto: CreateExternalStablecoinTransferDto - Transfer details
Returns: Transfertransfer_controller_create_stablecoin_conversion(create_stablecoin_conversion_dto)Convert between different stablecoins or networks.
from devdraft.model.create_stablecoin_conversion_dto import CreateStablecoinConversionDto conversion = transfers_api.transfer_controller_create_stablecoin_conversion( CreateStablecoinConversionDto( source_wallet_id = 'wallet-id' , destination_wallet_id = 'wallet-id' , source_network = 'ethereum' , destination_network = 'solana' , source_currency = 'usdc' , destination_currency = 'usdc' , amount = 1000.00 ) ) print ( f 'Conversion ID: { conversion.id } ' ) print ( f 'Exchange rate: { conversion.exchange_rate.rate } ' ) print ( f 'Estimated completion: { conversion.estimated_completion } ' )
Parameters:
create_stablecoin_conversion_dto: CreateStablecoinConversionDto - Conversion details
Returns: ConversionSee also: Stablecoin Conversion Guide Wallets Manage wallets and query balances.
Methods wallet_controller_get_wallets()Get all wallets for your application.
import devdraft with devdraft.ApiClient(configuration) as api_client: wallets_api = devdraft.WalletsApi(api_client) wallets_api.wallet_controller_get_wallets() # Returns wallet information for your application
Returns: NoneThe response contains wallet IDs that you can use for transfers and other operations. In a future SDK version, this will return typed wallet objects.
Webhooks Configure webhooks to receive real-time event notifications.
Methods webhook_controller_create(create_webhook_dto)Create a new webhook.
import devdraft from devdraft.model.create_webhook_dto import CreateWebhookDto with devdraft.ApiClient(configuration) as api_client: webhooks_api = devdraft.WebhooksApi(api_client) webhook = webhooks_api.webhook_controller_create( CreateWebhookDto( url = 'https://your-app.com/webhooks/devdraft' , name = 'Production Webhook' , is_active = True , encrypted = False ) ) print ( f 'Webhook ID: { webhook.id } ' ) print ( f 'Signing secret: { webhook.signing_secret } ' )
Parameters:
create_webhook_dto: CreateWebhookDto - Webhook configuration
Returns: WebhookResponseDtoSee also: Webhooks Overview webhook_controller_find_all(**kwargs)Get all webhooks.
webhooks = webhooks_api.webhook_controller_find_all( page = 1 , limit = 20 , active = True ) for webhook in webhooks: print ( f ' { webhook.name } : { webhook.url } ' ) print ( f 'Active: { webhook.is_active } ' )
Parameters:
page: int - Page number (optional)limit: int - Items per page (optional)active: bool - Filter by active status (optional)
Returns: List[WebhookResponseDto]webhook_controller_find_one(id)Get a webhook by ID.
webhook = webhooks_api.webhook_controller_find_one( id = 'webhook-id' ) print ( f 'Webhook: { webhook.name } ' ) print ( f 'URL: { webhook.url } ' ) print ( f 'Delivery stats: { webhook.delivery_stats } ' )
Parameters: Returns: WebhookResponseDtowebhook_controller_update(id, update_webhook_dto)Update a webhook.
from devdraft.model.update_webhook_dto import UpdateWebhookDto updated = webhooks_api.webhook_controller_update( id = 'webhook-id' , update_webhook_dto = UpdateWebhookDto( url = 'https://your-app.com/webhooks/new-endpoint' , is_active = True ) )
Parameters:
id: str - Webhook IDupdate_webhook_dto: UpdateWebhookDto - Fields to update
Returns: WebhookResponseDtowebhook_controller_remove(id)Delete a webhook.
webhooks_api.webhook_controller_remove( id = 'webhook-id' ) print ( 'Webhook deleted' )
Parameters: Returns: NoneError Handling All SDK methods may throw ApiException. Handle them appropriately:
from devdraft.rest import ApiException try : transfer = transfers_api.transfer_controller_create_direct_wallet_transfer(transfer_data) except ApiException as e: status_code = e.status response_body = e.body if status_code == 400 : print ( f 'Invalid request: { response_body } ' ) elif status_code == 401 : print ( 'Authentication failed - check your API credentials' ) elif status_code == 404 : print ( f 'Resource not found: { response_body } ' ) elif status_code == 422 : print ( f 'Validation error: { response_body } ' ) elif status_code == 429 : retry_after = e.headers.get( 'Retry-After' ) print ( f 'Rate limited - retry after: { retry_after } ' ) else : print ( f 'API error: { status_code } - { response_body } ' )
Type Hints The SDK includes type hints for better IDE support and type checking:
from devdraft.model.create_direct_wallet_transfer_dto import CreateDirectWalletTransferDto from devdraft.model.webhook_response_dto import WebhookResponseDto from devdraft.model.payment_response_dto import PaymentResponseDto # Type hints help with IDE autocomplete and type checking def create_transfer ( wallet_id : str , amount : float ) -> None : transfer_dto = CreateDirectWalletTransferDto( wallet_id = wallet_id, network = 'solana' , stable_coin_currency = 'usdc' , amount = amount ) transfer = transfers_api.transfer_controller_create_direct_wallet_transfer(transfer_dto)
Best Practices
Use Context Managers
Always use with statements to ensure proper resource cleanup. with devdraft.ApiClient(configuration) as api_client: transfers_api = devdraft.TransfersApi(api_client) # API calls here # Resources automatically cleaned up
Environment Variables for Credentials
Store API credentials in environment variables, never in source code. import os configuration.api_key[ 'x-client-key' ] = os.environ[ 'DEVDRAFT_CLIENT_KEY' ] configuration.api_key[ 'x-client-secret' ] = os.environ[ 'DEVDRAFT_CLIENT_SECRET' ]
Proper Exception Handling
Always wrap API calls in try-except blocks. from devdraft.rest import ApiException try : result = api.some_method() except ApiException as e: print ( f 'API error: { e.status } - { e.body } ' ) except Exception as e: print ( f 'Unexpected error: { e } ' )
Use Type Hints
Leverage Python’s type hints for better code quality. from typing import Optional from devdraft.model.customer import Customer def get_customer_by_email ( email : str ) -> Optional[Customer]: customers = customers_api.customer_controller_find_all() return next ((c for c in customers if c.email == email), None )
Reuse ApiClient
Create a single configuration and ApiClient instance and reuse it. # Bad: Creating new client for each API with devdraft.ApiClient(config) as client1: transfers_api = devdraft.TransfersApi(client1) with devdraft.ApiClient(config) as client2: webhooks_api = devdraft.WebhooksApi(client2) # Good: Reuse the same client with devdraft.ApiClient(config) as api_client: transfers_api = devdraft.TransfersApi(api_client) webhooks_api = devdraft.WebhooksApi(api_client)
Use Logging for Debugging
Enable logging for debugging API calls. import logging # Enable debug logging logging.basicConfig( level = logging. DEBUG ) configuration.debug = True # Enable SDK debug mode
Testing with Pytest Example pytest test for SDK integration:
import pytest import devdraft from devdraft.rest import ApiException @pytest.fixture def api_client (): configuration = devdraft.Configuration( host = "https://api.devdraft.ai" ) configuration.api_key[ 'x-client-key' ] = 'test-key' configuration.api_key[ 'x-client-secret' ] = 'test-secret' with devdraft.ApiClient(configuration) as client: yield client def test_create_webhook ( api_client ): webhooks_api = devdraft.WebhooksApi(api_client) webhook = webhooks_api.webhook_controller_create( devdraft.CreateWebhookDto( url = 'https://test.example.com/webhook' , name = 'Test Webhook' , is_active = True ) ) assert webhook.id is not None assert webhook.name == 'Test Webhook' def test_api_error_handling ( api_client ): transfers_api = devdraft.TransfersApi(api_client) with pytest.raises(ApiException) as exc_info: transfers_api.transfer_controller_create_direct_wallet_transfer( devdraft.CreateDirectWalletTransferDto( wallet_id = 'invalid-id' , network = 'invalid-network' , stable_coin_currency = 'invalid' , amount =- 100 # Invalid amount ) ) assert exc_info.value.status in [ 400 , 422 ]
Async Support For async/await support, you can use aiohttp with the SDK:
import asyncio import devdraft async def async_example (): configuration = devdraft.Configuration( host = "https://api.devdraft.ai" ) configuration.api_key[ 'x-client-key' ] = 'your-key' configuration.api_key[ 'x-client-secret' ] = 'your-secret' async with devdraft.ApiClient(configuration) as api_client: health_api = devdraft.APIHealthApi(api_client) # Use async methods response = await health_api.health_controller_public_health_check_v0() print ( f 'Status: { response.status } ' ) # Run async function asyncio.run(async_example())
Next Steps
SDK Quickstart Complete integration guide with examples
Transfers Learn about initiating transfers
Webhooks Set up webhook notifications
API Reference Complete REST API documentation
