> ## 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.

# Integração com OAuth 2.0

> Aprenda como criar uma integração que usa autenticação OAuth 2.0

Este guia mostra como criar uma integração funcional que extrai dados de usuários de uma API que usa autenticação OAuth 2.0 e os envia para um endpoint de webhook. Ao final, você entenderá como as conexões OAuth 2.0 funcionam na RWS Integration.

## O que você vai construir

Você criará uma integração que:

1. **Extrai** registros de usuários de uma API que usa autenticação OAuth 2.0
2. **Transforma** os dados para um formato mais simples
3. **Envia** os resultados para webhook.site onde você pode inspecioná-los

Tempo necessário: aproximadamente 5 minutos.

## Pré-requisitos

* Acesso a um Workspace da RWS Integration
* Um navegador web

<Tip>
  Certifique-se de estar no Workspace correto usando o seletor de workspace na barra lateral antes de começar.
</Tip>

## Passo 1: Configure seu destino

Antes de criar a integração, crie um endpoint de destino onde você pode verificar os resultados.

1. Abra [webhook.site](https://webhook.site) em uma nova aba do navegador
2. O site gera automaticamente uma URL única (ex.: `https://webhook.site/abc123-def456-...`)
3. **Copie a parte do caminho único** (ex.: `/abc123-def456-...`), pois você precisará dela ao configurar a fase de Envio
4. Mantenha esta aba aberta para monitorar requisições recebidas

<Note>
  webhook.site é um serviço gratuito que captura e exibe requisições HTTP. É útil para testar integrações antes de conectar a sistemas de destino reais.
</Note>

## Passo 2: Crie a conexão de origem

Conexões definem como a RWS Integration se comunica com sistemas externos. Você criará uma para a API de origem.

1. Na barra lateral, clique em **Conexões**
2. Clique em **Nova Conexão**
3. Configure a conexão:

| Campo                        | Valor                     | Descrição                                              |
| ---------------------------- | ------------------------- | ------------------------------------------------------ |
| Nome                         | `OAuth 2.0 API`           | -                                                      |
| Tipo                         | `API`                     | -                                                      |
| URL                          | `https://api.example.com` | A URL base dos dados extraídos                         |
| Caminho base (URL base path) | `/`                       | O caminho base dos dados extraídos                     |
| Autenticação                 | `OAuth 2.0`               | O método de autenticação a usar                        |
| Token Type                   | `Bearer`                  | O tipo de token a usar                                 |
| Método                       | `POST`                    | O método HTTP a usar para a requisição de autenticação |
| Base URL                     | `https://api.example.com` | A URL base do endpoint de autenticação                 |
| Autenticação path            | `/oauth/token`            | O caminho para o endpoint de autenticação              |
| Token Path in Response       | `access_token`            | O caminho para o token no corpo da resposta            |

4. Clique em **Salvar**

## Passo 3: Crie a conexão de destino

Agora crie uma Conexão para seu destino webhook.site.

1. Clique em **Nova Conexão**
2. Configure a conexão:

| Campo                        | Valor                  |
| ---------------------------- | ---------------------- |
| Nome                         | `Webhook Destination`  |
| Tipo                         | `API`                  |
| URL                          | `https://webhook.site` |
| Caminho base (URL base path) | `/`                    |
| Autenticação                 | `Sem autenticação`     |

3. Clique em **Salvar**

## Passo 4: Crie a Integração

Com ambas as Conexões prontas, crie a Integração que move dados entre elas.

1. Na barra lateral, clique em **Integrações**
2. Clique em **Nova Integração**

### Configurações gerais

Configure as propriedades básicas da integração:

| Campo       | Valor                                          |
| ----------- | ---------------------------------------------- |
| Nome        | `OAuth 2.0 Integration`                        |
| Versão      | `1.0.0`                                        |
| Tipo        | `Full`                                         |
| Ambiente    | `Staging`                                      |
| Agendamento | Diária, no horário que preferir (ex.: `09:00`) |

### Fase de Extração

A fase de Extração recupera dados do seu sistema de origem.

1. Expanda a seção **Extração**
2. Configure estes campos:

| Campo              | Valor           |
| ------------------ | --------------- |
| Conexão            | `OAuth 2.0 API` |
| Método             | `GET`           |
| Caminho (URL path) | `/users`        |

3. Defina o **Path para o datapoint na resposta** como `root`

<Note>
  A RWS Integration manterá o Token de Autenticação atualizado solicitando um novo token para cada requisição.
</Note>

4. Verifique o painel **Preview de Extração** no lado direito. Ele deve mostrar:
   * Status: `200 OK`
   * Um único registro de usuário (o Datapoint) com campos como `id`, `name`, `email`, `username`

### Fase de Transformação

A fase de Transformação mapeia campos de origem para o formato de destino. Para este guia, crie um mapeamento simples com três campos.

1. Expanda a seção **Transformação**
2. Clique em **Adicionar Transformação** e configure:

| Tipo    | Para           | De      |
| ------- | -------------- | ------- |
| Simples | `userId`       | `id`    |
| Simples | `fullName`     | `name`  |
| Simples | `emailAddress` | `email` |

3. Verifique o painel **Preview de Transformação**. Ele deve exibir:

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

Isso confirma que seus mapeamentos estão funcionando corretamente com dados reais da fase de Extração.

### Fase de Envio

A fase de Envio envia dados transformados para seu destino.

1. Expanda a seção **Envio**
2. Configure estes campos:

| Campo              | Valor                                                         |
| ------------------ | ------------------------------------------------------------- |
| Conexão            | `Webhook Destination`                                         |
| Método             | `POST`                                                        |
| Caminho (URL path) | Seu caminho único do webhook.site (ex.: `/abc123-def456-...`) |
| Tipo de Envio      | `Simples`                                                     |

<Warning>
  Copie apenas a parte do caminho da sua URL do webhook.site. Se sua URL completa for `https://webhook.site/abc-123`, insira `/abc-123` como o Path.
</Warning>

3. Verifique o painel **Preview de Envio**. Ele mostra a requisição completa que será enviada:
   * **Path**: URL completa de destino
   * **Method**: POST
   * **Request Body**: Sua estrutura de dados transformada

## Passo 5: Implante a Integração

1. Ative o toggle **Implantação**
2. Clique em **Criar Integração**

A integração agora será executada automaticamente todos os dias no horário que você escolheu.

## Passo 6: Execute agora

Você não precisa esperar o agendamento. Dispare a primeira execução manualmente:

1. Abra sua integração na lista de **Integrações**
2. Clique em **Executar agora**, ao lado do botão **Salvar**
3. Confirme no diálogo: a mensagem **Execução iniciada** aparece

## Passo 7: Verifique os resultados

Mude para a aba do webhook.site no seu navegador. Você deve ver requisições POST recebidas (uma para cada usuário da API), cada uma contendo sua estrutura de dados transformada:

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

Parabéns! Você criou e executou sua primeira integração com autenticação OAuth 2.0!