# Quick Start

By the end of this page a user has connected a financial institution and you are
reading their accounts and transactions. Five steps, whichever way you go through
them: create an application, get an API key, issue a connect token, open the widget,
read the data.

## Build it with an agent

Your agent can write this integration, and it writes a much better one when it is
reading our current documentation instead of remembering an older version of it.

### 1. Connect the docs

One hosted URL, no API key, nothing to install:

```bash
claude mcp add --transport http pluggy-docs https://mcp.pluggy.ai/mcp
```

Cursor, ChatGPT, Codex, VS Code, Windsurf and Gemini each take the same URL in their
own config — the exact snippet for each is on the
[MCP server](/docs/developer-tools/mcp) page. Adding our
[Agent Skill](/docs/developer-tools/ai-skills) on top gives it the integration
patterns to go with the reference.

### 2. Describe what you want

Paste this, with your stack filled in:

```text
Use the Pluggy Docs MCP server (pluggy-docs) for every Pluggy question — read the
current guides and OpenAPI spec before writing code, and cite the pages you used.

Build a minimal Pluggy integration in <your language / framework>:

1. A server route that exchanges CLIENT_ID and CLIENT_SECRET for an API key.
2. A server route that issues a connect token for a given user.
3. A frontend page that opens the Pluggy Connect widget with that token and
   stores the itemId from its onSuccess callback.
4. A server route that lists that item's accounts and its transactions,
   handling pagination.

Rules: CLIENT_SECRET never leaves the server, credentials come from environment
variables, and the item's status is handled — not every connection is ready the
moment the widget closes.
```

Then ask it the questions you would otherwise have searched for — *why is this item
in `WAITING_USER_INPUT`?*, *what does this webhook event mean?* — and it will answer
from the same pages you are reading now.

### 3. What is still yours to do

An agent cannot sign up for you. Create the account and the application in step 1
below, put the credentials in your environment, and read the code it wrote before
running it against anything real — the Sandbox exists for exactly that.

<Callout variant="info" title="No agent, or one you cannot configure?">
Every page here has a markdown twin: add `.md` to any docs URL. The full index is at
[`/llms.txt`](https://v2.docs.pluggy.ai/llms.txt), the whole site as one file is at
[`/llms-full.txt`](https://v2.docs.pluggy.ai/llms-full.txt), and the OpenAPI spec is
at [`/openapi/pluggy-api.json`](https://v2.docs.pluggy.ai/openapi/pluggy-api.json).
The **Copy for LLM** button at the top of each page gives you the same thing for a
single page.
</Callout>

## Or do it by hand

> **Start even faster**
>
> Check out our [quickstart repository](https://github.com/pluggyai/quickstart) on GitHub -- it contains ready-to-run sample apps (Node, Python, Java, and frontend examples) that implement this entire flow.

### 1. Create your account and application

1. Sign up at the [Pluggy Dashboard](https://dashboard.pluggy.ai).
2. Create an **application**. Every application has its own `CLIENT_ID` and `CLIENT_SECRET` -- you'll find them on the application's page in the Dashboard.

New applications start with access to our [Sandbox connectors](/docs/guides/sandbox), so you can test the whole flow with fake institutions before going to production.

### 2. Get an API Key

Authenticate with your credentials to get an API Key. This step must be done from your **server** -- never expose your `CLIENT_SECRET` in client-side code.

```bash
curl -X POST https://api.pluggy.ai/auth \
  -H "Content-Type: application/json" \
  -d '{
    "clientId": "YOUR_CLIENT_ID",
    "clientSecret": "YOUR_CLIENT_SECRET"
  }'
```

The response contains an `apiKey`, valid for 2 hours, with full access to the API:

```json
{
  "apiKey": "eyJhbGciOiJIUzI1..."
}
```

### 3. Create a Connect Token

To let your users connect their accounts from your app, create a short-lived Connect Token (valid for 30 minutes) with your API Key:

```bash
curl -X POST https://api.pluggy.ai/connect_token \
  -H "Content-Type: application/json" \
  -H "X-API-KEY: YOUR_API_KEY" \
  -d '{}'
```

The response contains an `accessToken` -- this is the token you pass to the widget. See [Authentication](/docs/authentication) for the full details on scopes and options.

### 4. Open the Connect Widget

Use the [Connect Widget](/docs/connect-widget/introduction) in your frontend, initialized with the `accessToken` from the previous step. The widget handles the entire authentication flow with the financial institution and creates an [Item](/docs/connections/item) -- the representation of the user's connection. Grab the `itemId` from the widget's `onSuccess` event.

### 5. Fetch the data

With the connection created, use your API Key (server-side) to retrieve the data:

```bash
# List the accounts of the connection
curl "https://api.pluggy.ai/accounts?itemId=YOUR_ITEM_ID" \
  -H "X-API-KEY: YOUR_API_KEY"

# List the transactions of an account
curl "https://api.pluggy.ai/transactions?accountId=YOUR_ACCOUNT_ID" \
  -H "X-API-KEY: YOUR_API_KEY"
```

## Next steps

- Understand the core concepts in the [Glossary](/docs/get-started/glossary)
- Test every flow with the [Sandbox](/docs/guides/sandbox)
- Explore all endpoints in the [API Reference](/reference)