{
  "args": {
    "parameter1": "value1"
  },
  "use_states": ["session-name"]
}

from witrium.client import SyncWitriumClient

with SyncWitriumClient(api_token=API_TOKEN) as client:
    result = client.run_workflow_and_wait(
        workflow_id=WORKFLOW_ID,
        args={"search_term": "vacuum cleaners"},
        use_states=["linkedin-login-session"]
    )

# Step 1: Login and preserve session
curl -X POST \
  -H "X-Witrium-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  "https://api.witrium.com/v1/workflows/LOGIN_WORKFLOW_ID/run" \
  -d '{
    "args": {
      "email": "user@example.com",
      "$password": "secret_password"
    },
    "preserve_state": "linkedin-session"
  }'

# Step 2: Use session for data extraction
curl -X POST \
  -H "X-Witrium-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  "https://api.witrium.com/v1/workflows/EXTRACTION_WORKFLOW_ID/run" \
  -d '{
    "use_states": ["linkedin-session"]
  }'

# Bash script for parallel execution
#!/bin/bash

WORKFLOW_ID="YOUR_WORKFLOW_ID"
API_KEY="YOUR_API_KEY"

# Function to run single page
run_page() {
  local page=$1
  local url="https://example.com/search?page=$page"
  
  curl -X POST \
    -H "X-Witrium-Key: $API_KEY" \
    -H "Content-Type: application/json" \
    "https://api.witrium.com/v1/workflows/$WORKFLOW_ID/run" \
    -d "{\"args\": {\"url\": \"$url\"}}" \
    -s | jq -r '.run_id'
}

# Launch multiple pages in parallel
for i in {1..10}; do
  run_page $i &
done

wait  # Wait for all background jobs to complete

from witrium.client import SyncWitriumClient

with SyncWitriumClient(api_token="your-api-token") as client:
    # Simple workflow execution with automatic waiting
    result = client.run_workflow_and_wait(
        workflow_id="workflow-id",
        args={"key": "value"}
    )
    print(result.result)

import csv
from concurrent.futures import ThreadPoolExecutor, as_completed
from witrium.client import SyncWitriumClient

def run_single_page(client, page_num):
    """Run workflow for a single page"""
    result = client.run_workflow_and_wait(
        workflow_id="your-workflow-id",
        args={"page": page_num}
    )
    return result.result if result.status == "COMPLETED" else None

# Run multiple pages in parallel
with SyncWitriumClient(api_token="your-api-token") as client:
    pages = range(1, 11)  # Pages 1-10
    results = []
    
    with ThreadPoolExecutor(max_workers=4) as executor:
        futures = {executor.submit(run_single_page, client, p): p for p in pages}
        
        for future in as_completed(futures):
            page = futures[future]
            try:
                result = future.result()
                if result:
                    results.append(result)
                    print(f"Page {page} completed")
            except Exception as e:
                print(f"Page {page} failed: {e}")
    
    print(f"Collected {len(results)} results")

import time
from witrium.client import SyncWitriumClient, WorkflowRunStatus

def run_with_retry(client, workflow_id, args, max_retries=3):
    """Run workflow with exponential backoff retry"""
    for attempt in range(max_retries):
        try:
            result = client.run_workflow_and_wait(
                workflow_id=workflow_id,
                args=args
            )
            
            if result.status == WorkflowRunStatus.COMPLETED:
                return result.result
            else:
                raise Exception(f"Workflow failed: {result.error_message}")
                
        except Exception as e:
            print(f"Attempt {attempt + 1} failed: {e}")
            if attempt == max_retries - 1:
                raise e
            time.sleep(2 ** attempt)  # Exponential backoff

import csv
import os
from urllib.parse import quote_plus
from witrium.client import SyncWitriumClient

def save_to_csv(data, filename="results.csv"):
    """Save extracted data to CSV"""
    is_new = not os.path.exists(filename)
    with open(filename, "a", newline="", encoding="utf-8") as f:
        if data and len(data) > 0:
            writer = csv.DictWriter(f, fieldnames=data[0].keys())
            if is_new:
                writer.writeheader()
            writer.writerows(data)

def scrape_search_results(search_term, max_pages=10):
    """Scrape search results across multiple pages"""
    API_TOKEN = "your-api-token"
    WORKFLOW_ID = "your-workflow-id"
    
    with SyncWitriumClient(api_token=API_TOKEN) as client:
        all_results = []
        
        for page in range(1, max_pages + 1):
            try:
                # Dynamic URL construction
                search_url = f"https://example.com/search?q={quote_plus(search_term)}&page={page}"
                
                result = client.run_workflow_and_wait(
                    workflow_id=WORKFLOW_ID,
                    args={"url": search_url}
                )
                
                if result.status == "COMPLETED" and result.result:
                    items = result.result.get("items", [])
                    # Add page metadata
                    for item in items:
                        item["page"] = page
                        item["search_term"] = search_term
                    
                    all_results.extend(items)
                    save_to_csv(items, f"{search_term}_results.csv")
                    print(f"Page {page}: {len(items)} items")
                
            except Exception as e:
                print(f"Page {page} failed: {e}")
        
        return all_results

# Usage
results = scrape_search_results("vacuum cleaners", max_pages=5)
print(f"Total items collected: {len(results)}")