Base94 with Python

Managing complex data pipelines and automating repetitive tasks is a common hurdle for developers. This guide dives into Base94, showcasing how to leverage its robust API with Python for efficient data manipulation and workflow orchestration. You'll learn to build custom integrations, automate deployments, and extract valuable insights, ultimately saving significant development time and reducing manual errors. Expect practical code examples and clear explanations to get you up and running quickly.

Connecting to

Establishing a connection to the Base94 API from your Python application is straightforward using the requests library. You'll make an HTTP POST request to the designated /v1/connect endpoint. This request requires specific authentication and client information to validate your access.

Here’s a practical example demonstrating the connection process:

import requests

api_url = "https://api.base94.com/v1/connect"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
payload = {"client_id": "YOUR_CLIENT_ID"}

response = requests.post(api_url, headers=headers, json=payload)

if response.status_code == 200:
    connection_token = response.json()["token"]
    print(f"Successfully connected: {connection_token}")
else:
    print(f"Connection failed: {response.status_code} - {response.text}")

A common pitfall is misformatting or omitting your API key and client ID. Double-check that your Authorization header and client_id in the payload are accurate; otherwise, authentication will fail. Always verify your credentials before attempting to connect.

Authenticating API Requests

Once you've established a connection and received your authentication token, subsequent interactions with the Base94 API require this token for verification. You'll append the obtained connection token to each API request within the Authorization header, formatted as a Bearer token. This ensures that only authorized clients can access your data.

Here’s a practical example using Python's requests library:

import requests

api_endpoint = "https://api.base94.com/v1/data/items"
headers = {"Authorization": f"Bearer {connection_token}"} # Replace connection_token with your actual token

response = requests.get(api_endpoint, headers=headers)

if response.status_code == 200:
    items_data = response.json()
    print(f"Successfully retrieved {len(items_data)} items.")
else:
    print(f"Error: {response.status_code} - {response.text}")

A common pitfall to watch for is token expiration. Tokens have a limited lifespan, and attempting to use an expired token will result in an authentication error. Always build logic to handle potential token invalidity by re-establishing your connection and fetching a new token when necessary.

Making Data Queries

Effectively retrieving data from Base94 involves constructing precise query parameters. These parameters dictate the filters and criteria for your requests, ensuring you get exactly the information you need. For most operations, you'll be building JSON payloads to send with POST requests.

For instance, to fetch all active items created after January 1st, 2023, you’d construct a payload like this:

import requests
from datetime import datetime

api_endpoint = "https://api.base94.com/v1/data/items/query"
headers = {"Authorization": f"Bearer {connection_token}"}
query_payload = {
    "filter": {
        "status": "active",
        "created_at__gte": "2023-01-01T00:00:00Z"
    },
    "limit": 50
}
response = requests.post(api_endpoint, headers=headers, json=query_payload)

if response.status_code == 200:
    active_items = response.json()["results"]
    print(f"Found {len(active_items)} active items.")
else:
    print(f"Query failed: {response.status_code} - {response.text}")

A common pitfall is misinterpreting the API's specific filtering syntax. Always consult the Base94 API documentation for the correct field names and available comparison operators, such as __gte for "greater than or equal to" or __contains. Mastering this syntax is key to precise data retrieval.

Handling Responses and Errors

Base94 API responses arrive in JSON format, which Python can easily parse. You'll typically use the requests library's response.json() method for this. After a successful request (status code 200), iterate through the resulting data, checking for specific fields.

Consider this practical example: after fetching a list of active items, you might want to identify high-priority tasks.

if response.status_code == 200:
    active_items = response.json().get("data", []) # Safely get 'data' or an empty list
    for item in active_items:
        if item.get("priority") == "high":
            print(f"High priority item found: {item.get('name')}")

A common pitfall is encountering unexpected JSON structures or missing keys. Always use the .get() method when accessing dictionary elements to prevent KeyError exceptions. Crucially, verify response.status_code is 200 before attempting to parse the body. This ensures you're working with valid data.