5 Must-Know Things About The Launch Of The Unmeshed Python SDK

We're excited to announce the launch of the Unmeshed Python SDK -- designed to make it even easier for developers to integrate, orchestrate and scale workflows using Python. Whether you're building API-driven apps, managing background workers, or stitching together services, this SDK gives you the power of Unmeshed directly in your favorite programming language.

The Unmeshed Python SDK gives your team a faster, cleaner, and more scalable way to build backend workflows and service integrations. You no longer need to write glue code, stitch together APIs manually, or deal with orchestration complexity. Everything from execution to error handling to scaling is built in. Here are the top 5 things you need to know about what's new and what you can do.

Simple Installation & Credential Setup

Getting started is a breeze -- install the SDK via pip and initialize UnmeshedClient using your credentials. The setup takes minutes and fits seamlessly into any Python project.

from unmeshed.sdk.configs.client_config import ClientConfig
from unmeshed.sdk.unmeshed_client import UnmeshedClient

def main():

client_config = ClientConfig()
client_config.set_client_id ("your-client-id")#Replace with your API 🆔 client ID
client_config.set_auth_token ("your-auth-token")#Replace with your API 🔒 auth token
client_config.set_port (8080)#Replace with your Unmeshed API port 🚪
client_config.set_base_url ("http://localhost")#Replace with your Unmeshed API endpoint 🌐

client_config.set_initial_delay_millis(50)
client_config.set_step_timeout_millis(3600000)
client_config.set_work_request_batch_size(200)
client_config.set_response_submit_batch_size(1000)
client_config.set_max_threads_count(10)
client_config.set_poll_interval_millis(10)
client = UnmeshedClient(client_config)

Flexible Worker Registration

Define your worker functions (sync or async), register them using register_worker() and Unmeshed will automatically invoke them when the corresponding step in a process is triggered. You can also use annotations to register workers declaratively --- keeping your code clean and expressive

Run Processes — Your Way

The SDK supports both synchronous and asynchronous process execution. Need a quick result? Use run_process_sync().

from unmeshed.sdk.common.process_data import ProcessData
from unmeshed.sdk.common.process_request_data import ProcessRequestData

process_request = ProcessRequestData(
    namespace="default",
    name="test_process",
    version=1,
    requestId="req001",
    correlationId="corr001",
    input={
        "test1": "value",
        "test2": 100,
        "test3": 100.0,
    }
)

process_data = client.run_process_sync(process_request)

For long-running tasks or non-blocking workflows, fire off run_process_async() and keep going.

process_data2 = client.run_process_async(process_request)
logger.info(
    f"Async execution of process request %s returned %s",
    process_request,
    process_data2.to_json()
)

Advanced Execution Control

With the SDK, you can retrieve process in bulk if needed. Below are some of the flexible options for retrieving processes based on various search criteria.

• retrieve (get_step_data)

• rerun (rerun)

• terminate (bulk_terminate)

• resume (bulk_resume)

• review (bulk_reviewed) and more processes in bulk if needed. You can also dig into specific steps, search executions by filters, and invoke API mappings directly using GET or POST request.

GET API Mapping Invocation

response = 
client.invoke_api_mapping_get(endpoint="test_process_endpoint", 
correlation_id="correl_id--1", 
_id="req_id--1",api_call_type=ApiCallType.SYNC)

logger.info(
    f"API mapped endpoint invocation using GET returned %s", response
)

Post API Mapping Invocation

response = client.invoke_api_mapping_post(endpoint="test_process_endpoint", correlation_id="correl_id--1", _id="req_id--1", api_call_type=ApiCallType.SYNC, _input={"test": "value"})
logger.info(
    f"API mapped endpoint invocation using POST returned %s", response
)

Scalable Worker Concurrency

Need to scale? The SDK is built for it. You can fine-tune thread pools, polling intervals, and concurrency settings --- and even run multiple worker instances to handle large workloads. Whether your workers are short-lived or I/O-heavy, Unmeshed gives you the control to scale efficiently.

Developers can work in native Python, use familiar function patterns, and leave the heavy lifting to the platform --- reducing engineering time, boosting performance, and increasing observability across the board.

👉 Ready to try it out? Explore the SDK , Get started with Unmeshed or check out Azure MarketPlace.