Python

pip install bundleup-sdk

import os
import logging
from bundleup import BundleUp

# Initialize the client with your API key
client = BundleUp(os.getenv("BUNDLEUP_API_KEY"))

# List all connections
connections = client.connections.list()
logging.info(connections)

import os
from bundleup import BundleUp

# Initialize with API key
client = BundleUp('your_api_key_here')

# Or use environment variable (recommended)
client = BundleUp(os.getenv("BUNDLEUP_API_KEY"))

from bundleup import BundleUp

# Regular usage
client = BundleUp("your-api-key")

# Context manager (automatically closes connections)
with BundleUp("your-api-key") as client:
    connections = client.connections.list()

# List all connections
connections = client.connections.list()

# Create a new connection
connection = client.connections.create({
    "name": "My Connection",
    "integration_id": "integration-id"
})

# Retrieve a specific connection
connection = client.connections.retrieve("connection-id")

# Delete a connection
client.connections.delete("connection-id")

# List all integrations
integrations = client.integrations.list()

# Retrieve a specific integration
integration = client.integrations.retrieve("integration-id")

# List all webhooks
webhooks = client.webhooks.list()

# Create a new webhook
webhook = client.webhooks.create({
    "url": "https://example.com/webhook",
    "events": ["connection.created"]
})

# Update a webhook
updated = client.webhooks.update("webhook-id", {
    "url": "https://example.com/new-webhook"
})

# Delete a webhook
client.webhooks.delete("webhook-id")

# Create a proxy instance
proxy = client.proxy("connection-id")

# Make requests to the connected service
response = proxy.get("/users")
response = proxy.post("/users", {"name": "John"})
response = proxy.put("/users/123", {"name": "Jane"})
response = proxy.patch("/users/123", {"email": "jane@example.com"})
response = proxy.delete("/users/123")

# Get unified chat channels
channels = client.unify("connection-id").chat.channels()

# With pagination parameters
channels = client.unify("connection-id").chat.channels({
    "limit": 50,
    "include_raw": True
})

unify = client.unify("connection-id")

# Get repositories
repos = unify.git.repos()

# Get pull requests
pulls = unify.git.pulls()

# Get tags
tags = unify.git.tags()

# Get releases
releases = unify.git.releases()

# Get issues
issues = client.unify("connection-id").pm.issues()

# With pagination
issues = client.unify("connection-id").pm.issues({
    "limit": 100,
    "after": "cursor-id"
})

from bundleup import BundleUp
from bundleup.exceptions import (
    BundleUpError,          # Base exception
    ValidationError,        # Input validation errors
    APIError,              # General API errors
    AuthenticationError,   # 401 errors
    NotFoundError,        # 404 errors
    RateLimitError        # 429 errors
)

try:
    client = BundleUp("your-api-key")
    connections = client.connections.list()
except AuthenticationError:
    print("Invalid API key")
except NotFoundError:
    print("Resource not found")
except RateLimitError:
    print("Rate limit exceeded")
except APIError as e:
    print(f"API error: {e.status_code} - {e}")
except ValidationError as e:
    print(f"Validation error: {e}")

import requests
from bundleup import BundleUp

session = requests.Session()
session.timeout = 30
session.verify = True

client = BundleUp("your-api-key", session=session)