Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.bundleup.io/llms.txt

Use this file to discover all available pages before exploring further.

Get started with BundleUp in a Django application. This guide walks you through connecting to a third-party API (GitHub, in this example) and then using the resulting connection_id to fetch data through the BundleUp unified API. By the end of this guide, you’ll:
  • Redirect a user through an OAuth-style authorization flow
  • Receive a connection_id
  • Use that connection_id to make unified API calls via BundleUp

​
Prerequisites

Before you begin, make sure you have:
  • A BundleUp account
  • A BundleUp API key (server-side)
  • Your BundleUp Client ID (used for authorization redirects)
  • An Integration ID for the service you want to connect (for example, github)
  • Python 3.10+ installed
You can find your API key, Client ID, and Integration IDs in the BundleUp dashboard.

​
Step 1: Create a Django project

If you don’t already have a Django project: 
# create and activate a virtual environment
python -m venv .venv
source .venv/bin/activate

# install Django
pip install Django

# create a new project
django-admin startproject bundleup_django
cd bundleup_django

# create an app
python manage.py startapp core

​
Step 2: Install the BundleUp Python SDK

Install the official BundleUp SDK from PyPI: 
pip install bundleup-sdk
This package lets your Django server use BundleUp’s unified API to fetch data after a user has authorized an integration.

​
Step 3: Configure Django settings

Add Django view URLs and your environment configuration:
  1. Create a .env file in your project root with:
.env
# server-side only
BUNDLEUP_API_KEY=your_api_key_here

# used for redirect
BUNDLEUP_CLIENT_ID=your_client_id_here
BUNDLEUP_INTEGRATION_ID=github
BUNDLEUP_REDIRECT_URI=http://localhost:8000/callback
  1. Load these environment variables in settings.py (you can use python-dotenv or your own loader).
  2. In bundleup_django/urls.py, add routes:
bundleup_django/urls.py
from django.urls import path
from core import views

urlpatterns = [
    path("", views.home, name="home"),
    path("callback", views.callback, name="callback"),
]
In core/views.py, add a view that redirects a user to the BundleUp authorization endpoint:
core/views.py
import os
from django.http import HttpResponseRedirect
from django.shortcuts import render

def home(request):
    client_id = os.getenv("BUNDLEUP_CLIENT_ID")
    integration_id = os.getenv("BUNDLEUP_INTEGRATION_ID")
    redirect_uri = os.getenv("BUNDLEUP_REDIRECT_URI")

    url = (
        f"https://auth.bundleup.io/authorize?"
        f"client_id={client_id}"
        f"&integration_id={integration_id}"
        f"&redirect_uri={redirect_uri}"
    )

    return render(
        request,
        "home.html",
        {"auth_url": url}
    )
Create a simple template core/templates/home.html with:
core/templates/home.html
<a href="{{ auth_url }}">Connect GitHub</a>
Clicking this link sends users to authorize GitHub, and then they’re redirected back to /callback.

​
Step 5: Handle the callback and fetch data

When BundleUp redirects back to /callback, it includes a connection_id query parameter. Here’s how to read it and make a unified API call with the Python SDK:
core/views.py
import os
from django.shortcuts import render
from bundleup_sdk import BundleUp

def callback(request):
    error = request.GET.get("error")
    if error:
        return render(request, "callback.html", {"error": request.GET.get("error_description")})

    connection_id = request.GET.get("connection_id")
    client = BundleUp(os.getenv("BUNDLEUP_API_KEY"))

    # Example: fetch GitHub repos via unified API
    repos = client.unify(connection_id).git.repos()

    return render(request, "callback.html", {"repos": repos.data})
And in core/templates/callback.html:
core/templates/callback.html
{% if error %}
<p>Error: {{ error }}</p>
{% else %}
<h2>Your Repositories</h2>
<ul>
  {% for repo in repos %}
    <li>{{ repo.full_name }}</li>
  {% endfor %}
</ul>
{% endif %}
What’s happening here
  • connection_id ties a user + integration together
  • The Python SDK then makes authenticated calls using that connection
  • You can fetch repositories, calendar events, files, contacts, etc., depending on the integration

​
Step 6: Run your development server

Start the Django server: 
python manage.py runserver
Visit http://localhost:8000, click Connect GitHub, authorize, and you’ll see a list of repositories.

​
What’s next?

  • Persist connection_id to your database for later use
  • Add authenticated views that use the Python SDK to fetch user data
  • Support additional integrations with no auth changes