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

# Integration with OAuth 2.0

> Learn how to create an integration that uses OAuth 2.0 authentication

This guide walks you through creating a working integration that extracts user data from an API that uses OAuth 2.0 authentication and delivers it to a webhook endpoint. By the end, you'll understand how OAuth 2.0 connections work inside RWS Integration.

## What you'll build

You'll create an integration that:

1. **Extracts** user records from an API that uses OAuth 2.0 authentication
2. **Transforms** the data to a simpler format
3. **Loads** the results to webhook.site where you can inspect them

Time required: approximately 5 minutes.

## Prerequisites

* Access to an RWS Integration Workspace
* A web browser

<Tip>
  Make sure you're in the correct Workspace using the workspace selector in the sidebar before starting.
</Tip>

## Step 1: Set up your destination

Before building the integration, create a destination endpoint where you can verify the results.

1. Open [webhook.site](https://webhook.site) in a new browser tab
2. The site automatically generates a unique URL (e.g., `https://webhook.site/abc123-def456-...`)
3. **Copy the unique path portion** (e.g., `/abc123-def456-...`); you'll need it when configuring the Load phase
4. Keep this tab open to monitor incoming requests

<Note>
  webhook.site is a free service that captures and displays HTTP requests. It's useful for testing integrations before connecting to real destination systems.
</Note>

## Step 2: Create the source Connection

Connections define how RWS Integration communicates with external systems. You'll create one for the source API.

1. In the sidebar, click **Connections**
2. Click **New Connection**
3. Configure the connection:

| Field                  | Value                     | Description                                           |
| ---------------------- | ------------------------- | ----------------------------------------------------- |
| Name                   | `OAuth 2.0 API`           | -                                                     |
| Type                   | `API`                     | -                                                     |
| URL                    | `https://api.example.com` | The base URL of the extracted data                    |
| Base Path              | `/`                       | The base path of the extracted data                   |
| Authentication         | `OAuth 2.0`               | The authentication method to use                      |
| Token Type             | `Bearer`                  | The type of token to use                              |
| Method                 | `POST`                    | The HTTP method to use for the authentication request |
| Base URL               | `https://api.example.com` | The base URL of the authentication endpoint           |
| Authentication path    | `/oauth/token`            | The path to the authentication endpoint               |
| Token Path in Response | `access_token`            | The path to the token in the response body            |

4. Click **Save**

## Step 3: Create the destination Connection

Now create a Connection for your webhook.site destination.

1. Click **New Connection**
2. Configure the connection:

| Field          | Value                  |
| -------------- | ---------------------- |
| Name           | `Webhook Destination`  |
| Type           | `API`                  |
| URL            | `https://webhook.site` |
| Base Path      | `/`                    |
| Authentication | `No authentication`    |

3. Click **Save**

## Step 4: Create the Integration

With both Connections ready, create the Integration that moves data between them.

1. In the sidebar, click **Integrations**
2. Click **New Integration**

### General settings

Configure the basic integration properties:

| Field       | Value                                          |
| ----------- | ---------------------------------------------- |
| Name        | `OAuth 2.0 Integration`                        |
| Version     | `1.0.0`                                        |
| Type        | `Full`                                         |
| Environment | `Staging`                                      |
| Schedule    | Daily, at a time of your choice (e.g. `09:00`) |

### Extract phase

The Extract phase retrieves data from your source system.

1. Expand the **Extract** section
2. Configure these fields:

| Field      | Value           |
| ---------- | --------------- |
| Connection | `OAuth 2.0 API` |
| Method     | `GET`           |
| Path       | `/users`        |

3. Set the **Datapoint Path in Response** to `root`

<Note>
  RWS Integration will keep the Authentication Token refreshed by requesting a new token for each request.
</Note>

4. Check the **Extract Preview** panel on the right side. It should show:
   * Status: `200 OK`
   * A single user record (the Datapoint) with fields like `id`, `name`, `email`, `username`

### Transform phase

The Transform phase maps source fields to your destination format. For this guide, create a simple mapping with three fields.

1. Expand the **Transform** section
2. Click **Add Transformation** and configure:

| Type   | To             | From    |
| ------ | -------------- | ------- |
| Simple | `userId`       | `id`    |
| Simple | `fullName`     | `name`  |
| Simple | `emailAddress` | `email` |

3. Check the **Transform Preview** panel. It should display:

```json theme={null}
{
  "userId": 1,
  "fullName": "Leanne Graham",
  "emailAddress": "Sincere@april.biz"
}
```

This confirms your mappings are working correctly with real data from the Extract phase.

### Load phase

The Load phase sends transformed data to your destination.

1. Expand the **Load** section
2. Configure these fields:

| Field      | Value                                                      |
| ---------- | ---------------------------------------------------------- |
| Connection | `Webhook Destination`                                      |
| Method     | `POST`                                                     |
| Path       | Your webhook.site unique path (e.g., `/abc123-def456-...`) |
| Load Type  | `Simple`                                                   |

<Warning>
  Copy only the path portion from your webhook.site URL. If your full URL is `https://webhook.site/abc-123`, enter `/abc-123` as the Path.
</Warning>

3. Check the **Load Preview** panel. It shows the complete request that will be sent:
   * **Path**: Full destination URL
   * **Method**: POST
   * **Request Body**: Your transformed data structure

## Step 5: Deploy the Integration

1. Toggle **Deployment** to enabled
2. Click **Create Integration**

The integration will now run automatically every day at the time you chose.

## Step 6: Run it now

You don't need to wait for the schedule. Trigger the first run manually:

1. Open your integration from the **Integrations** list
2. Click **Run now**, next to the **Save** button
3. Confirm in the dialog, and a **Run started** message appears

## Step 7: Verify the results

Switch to your webhook.site browser tab. You should see incoming POST requests (one for each user from the API), each containing your transformed data structure:

```json theme={null}
{
  "userId": 1,
  "fullName": "Leanne Graham",
  "emailAddress": "Sincere@april.biz"
}
```

Congratulations, you've built and run your first integration with OAuth 2.0 authentication!