> ## Documentation Index
> Fetch the complete documentation index at: https://bundleup.io/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> From a new BundleUp account to your first API call against a user’s connected account, in about five minutes.

This guide uses **GitHub** as the example provider and cURL for the API calls, so it works with any language. Framework-specific versions are linked at the end.

```mermaid theme={null}
flowchart LR
    S1["1. Create an<br/>integration"] --> S2["2. Register a<br/>redirect URI"] --> S3["3. Create an<br/>API key"] --> S4["4. Connect an<br/>account"] --> S5["5. Exchange<br/>the code"] --> S6["6. Make a<br/>request"]
```

Steps 1 to 3 are one-time setup in the dashboard. Steps 4 to 6 are what your app does for every user who connects an account.

## Before you start

* A BundleUp account. [Sign up at app.bundleup.io](https://app.bundleup.io).
* A GitHub account, to create an OAuth app and to connect as a test user.

<Tip>
  Create a separate workspace for development and production. Each workspace has its own integrations, keys and redirect URIs. See [Workspaces](/docs/concepts/workspaces).
</Tip>

## 1. Create an integration

An integration tells BundleUp how to talk to a provider using **your** OAuth app.

<Steps>
  <Step title="Start a GitHub integration in BundleUp">
    In the dashboard, open **Integrations**, click to add one, and pick **GitHub**. Leave the form open. It shows a **Redirect URI** (`https://auth.bundleup.io/callback`) that you need in the next step.
  </Step>

  <Step title="Create a GitHub OAuth app">
    In GitHub, go to **Settings → Developer settings → OAuth Apps → New OAuth App**. Use `https://auth.bundleup.io/callback` as the **Authorization callback URL**. After creating it, generate a client secret.
  </Step>

  <Step title="Paste the credentials into BundleUp">
    Back in BundleUp, fill in:

    * **Identifier**: `github`. This is the name you’ll use in code to refer to this integration.
    * **Client ID** and **Client Secret** from your GitHub OAuth app.
    * **Scopes**: for this guide, `repo` and `read:user`.

    Save the integration.
  </Step>
</Steps>

Provider-specific setup notes are on each provider’s page at [bundleup.io/integrations](https://www.bundleup.io/integrations).

## 2. Register a redirect URI

After a user connects an account, BundleUp sends them back to a URL in **your** app. That URL must be registered first.

Open **Auth** in the dashboard, add `http://localhost:3000/callback` under **Redirect URIs**, and save. While you’re there, copy your **Client ID**. It identifies your workspace in the authorization URL.

<Note>
  This redirect URI is different from the one in step 1. The one in step 1 (`https://auth.bundleup.io/callback`) is where the **provider** sends users back to BundleUp. This one is where **BundleUp** sends users back to you.
</Note>

## 3. Create an API key

Open **API Keys** in the dashboard and create a key. Copy it and keep it on your server. It grants access to every connection in the workspace.

```bash theme={null}
export BUNDLEUP_API_KEY="YOUR_API_KEY"
```

## 4. Connect an account

Send the user to BundleUp’s authorization URL. For this test, open it in your own browser:

```text theme={null}
https://auth.bundleup.io/authorize?client_id=YOUR_CLIENT_ID&integration_id=github&redirect_uri=http://localhost:3000/callback&state=abc123
```

Approve the GitHub consent screen. You’ll land on `http://localhost:3000/callback?state=abc123&code=...`. Nothing needs to be running on port 3000: copy the `code` from the address bar.

## 5. Exchange the code for a connection ID

From your server, within 5 minutes:

```bash theme={null}
curl -X POST https://auth.bundleup.io/connection \
  -H "Authorization: Bearer $BUNDLEUP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"code": "PASTE_CODE_HERE", "redirect_uri": "http://localhost:3000/callback"}'
```

```json theme={null}
{
  "connection_id": "conn_abc123",
  "external_id": null,
  "integration_id": "github"
}
```

Store the `connection_id`. In a real app you’d save it next to the user who connected it. It stays valid until the connection is deleted, so you only do this once per account.

## 6. Make a request

Call GitHub through the Proxy, using the provider’s own API path:

```bash theme={null}
curl https://proxy.bundleup.io/user \
  -H "Authorization: Bearer $BUNDLEUP_API_KEY" \
  -H "BU-Connection-Id: conn_abc123"
```

Or ask the Unified API, which returns the same shape for every Git provider:

```bash theme={null}
curl https://unify.bundleup.io/v1/git/repos?limit=5 \
  -H "Authorization: Bearer $BUNDLEUP_API_KEY" \
  -H "BU-Connection-Id: conn_abc123"
```

Open **Logs** in the dashboard to see both requests, with status code and duration.

## What you just did

* Set up an integration using your own OAuth app.
* Ran the authorization flow and turned a one-time `code` into a `connection_id`.
* Called the user’s GitHub account through the Proxy and the Unified API without touching a token.

## Next steps

<Columns cols={2}>
  <Card title="Next.js" icon="react" href="/docs/quickstart/next-js">
    The same flow inside a Next.js app.
  </Card>

  <Card title="Django" icon="python" href="/docs/quickstart/django">
    The same flow inside a Django app.
  </Card>

  <Card title="Rails" icon="gem" href="/docs/quickstart/rails">
    The same flow inside a Rails app.
  </Card>

  <Card title="AI agent" icon="microchip-ai" href="/docs/quickstart/ai-agent">
    Give an AI agent access to a connected account over MCP.
  </Card>
</Columns>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.