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

# Início Rápido

> Crie sua primeira integração em 5 minutos

Este guia mostra como criar uma integração funcional que extrai dados de usuários de uma API pública e os entrega a um endpoint webhook. Ao final, você entenderá o fluxo principal: criar Conexões, construir uma Integração e executá-la.

## O que você vai construir

Você criará uma integração que:

1. **Extrai** registros de usuários do JSONPlaceholder (uma API de teste gratuita)
2. **Transforma** os dados para um formato mais simples
3. **Carrega** os resultados no webhook.site onde você pode inspecioná-los

Tempo necessário: aproximadamente 5 minutos.

## Pré-requisitos

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

## Passo 1: Configure seu destino

Antes de construir 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 esta URL**: você precisará dela ao criar sua Conexão de destino
4. Mantenha esta aba aberta para monitorar as 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 o 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 **Criar Conexão**
3. Configure a conexão:

| Campo                        | Valor                                  |
| ---------------------------- | -------------------------------------- |
| Nome                         | `JSONPlaceholder API`                  |
| Tipo                         | `API`                                  |
| URL                          | `https://jsonplaceholder.typicode.com` |
| Caminho base (URL base path) | `/`                                    |
| Autenticação                 | `Sem autenticação`                     |

4. Clique em **Salvar**

A API JSONPlaceholder não requer autenticação, então a opção **Sem autenticação**, já selecionada por padrão para novas conexões, é tudo o que você precisa.

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

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

1. Clique em **Criar 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 **Criar Integração**

### Configurações gerais

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

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

<Note>
  O agendamento é definido com um seletor de frequência: escolha com que frequência a integração executa e preencha os detalhes, como o horário do dia. Veja [Agendamento](/pt-br/features/extract/scheduling) para todas as opções.
</Note>

### 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            | `JSONPlaceholder API` |
| Método             | `GET`                 |
| Caminho (URL path) | `/users`              |

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

4. Defina a **Paginação**:

| Campo                          | Valor     |
| ------------------------------ | --------- |
| Tipo                           | `Simples` |
| Parâmetro do tamanho da página | `_limit`  |
| Valor do tamanho da página     | `10`      |
| Parâmetro da página            | `_page`   |
| Valor da página inicial        | `1`       |
| Tipo de fim de paginação       | `Objeto`  |

5. 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 início rápido, crie um mapeamento simples com três campos.

1. Expanda a seção **Transformação**
2. Clique em **Adicionar** 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 é `https://webhook.site/abc-123`, insira `/abc-123` como o caminho.
</Warning>

3. Verifique o painel **Preview de Envio**. Ele mostra a requisição completa que será enviada:
   * **Caminho**: URL completa do destino
   * **Método**: POST
   * **Corpo da requisição**: Sua estrutura de dados transformada

## Passo 5: Implante a Integração

1. Habilite o **Agendamento para deploy**
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

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

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

Parabéns! Você construiu e executou sua primeira integração!

## O que você aprendeu

* **Conexões** armazenam configurações para sistemas externos e podem ser reutilizadas em múltiplas Integrações
* **Integrações** seguem o padrão Extração → Transformação → Envio (com Enriquecimento opcional)
* O **Path para o datapoint** indica ao RWS Integration onde encontrar registros nas respostas da API
* **Painéis de Preview** atualizam automaticamente conforme você configura cada fase, permitindo validar antes de executar
* **Transformações simples** mapeiam campos da origem para o destino usando notação JSONPath
* **Ambientes** (Staging/Produção) permitem testar com segurança antes de implantar em produção
* **Executar agora** dispara uma execução sob demanda, sem esperar o agendamento

## Próximos passos

<CardGroup cols={2}>
  <Card title="Conexões" icon="plug" href="/pt-br/features/connections/api">
    Aprenda sobre os diferentes métodos de autenticação
  </Card>

  <Card title="Paginação" icon="arrows-rotate" href="/pt-br/features/extract/pagination">
    Lide com paginação e respostas de API complexas
  </Card>

  <Card title="Regras de Negócio" icon="code" href="/pt-br/features/business-rules/overview">
    Domine transformações de campos com JavaScript
  </Card>

  <Card title="Agendamento" icon="clock" href="/pt-br/features/extract/scheduling">
    Agende suas integrações para executar automaticamente
  </Card>
</CardGroup>