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

# Início rápido

> Conecte uma sessão do WhatsApp, escaneie o QR code ou use código de pareamento e responda sua primeira mensagem em menos de cinco minutos com o zapo.

Este guia constrói um bot mínimo de "ping → pong". Ele se conecta, imprime um QR code para parear e responde `pong` sempre que recebe `ping`.

<Steps>
  <Step title="Instale os pacotes">
    ```bash theme={null}
    npm install zapo-js @zapo-js/store-sqlite better-sqlite3 pino pino-pretty
    ```
  </Step>

  <Step title="Crie a store e o client">
    A [store](/pt-br/concepts/stores) persiste o estado de auth e do Signal. Este exemplo usa SQLite, gravando em `.auth/state.sqlite`.

    ```ts theme={null}
    import { createPinoLogger, createStore, WaClient } from 'zapo-js'
    import { createSqliteStore } from '@zapo-js/store-sqlite'

    const logger = await createPinoLogger({ level: 'info', pretty: true })

    const store = createStore({
      backends: {
        sqlite: createSqliteStore({ path: '.auth/state.sqlite', driver: 'auto' })
      },
      providers: {
        auth: 'sqlite',
        signal: 'sqlite',
        preKey: 'sqlite',
        session: 'sqlite',
        identity: 'sqlite',
        senderKey: 'sqlite',
        appState: 'sqlite',
        privacyToken: 'sqlite',
        messages: 'sqlite',
        threads: 'sqlite',
        contacts: 'sqlite'
      }
    })

    const client = new WaClient(
      {
        store,
        sessionId: 'default',
        connectTimeoutMs: 15_000,
        nodeQueryTimeoutMs: 30_000,
        history: { enabled: true, requireFullSync: true }
      },
      logger
    )
    ```
  </Step>

  <Step title="Trate o pareamento">
    Em uma sessão nova, o client emite `auth_qr`. Renderize o valor como um QR code (por exemplo, com o pacote [`qrcode-terminal`](https://www.npmjs.com/package/qrcode-terminal)) e escaneie a partir de **WhatsApp → Aparelhos conectados**.

    ```ts theme={null}
    client.on('auth_qr', ({ qr, ttlMs }) => {
      console.log('Scan this QR within', ttlMs, 'ms:')
      console.log(qr)
    })

    client.on('auth_paired', ({ credentials }) => {
      console.log('Paired as', credentials.meJid)
    })
    ```

    <Tip>
      Prefere um **código de pareamento de 8 caracteres** em vez de um QR? Veja [Autenticação](/pt-br/concepts/authentication#pairing-with-a-code).
    </Tip>
  </Step>

  <Step title="Responda mensagens recebidas">
    Escute o evento `message` e envie uma resposta com `client.message.send`.

    ```ts theme={null}
    function extractText(message) {
      return (
        message?.conversation ??
        message?.extendedTextMessage?.text ??
        undefined
      )
    }

    client.on('message', async (event) => {
      const text = extractText(event.message)
      if (text?.trim().toLowerCase() !== 'ping') return

      await client.message.send(event.key.remoteJid, 'pong')
    })
    ```
  </Step>

  <Step title="Conecte">
    ```ts theme={null}
    await client.connect()
    ```

    O `connect()` resolve assim que o socket está aberto. A primeira conexão conduz o pareamento; conexões subsequentes reutilizam as credenciais armazenadas.
  </Step>
</Steps>

<h2 id="full-example">
  Exemplo completo
</h2>

```ts theme={null}
import { createPinoLogger, createStore, WaClient } from 'zapo-js'
import { createSqliteStore } from '@zapo-js/store-sqlite'

const logger = await createPinoLogger({ level: 'info', pretty: true })

const store = createStore({
  backends: {
    sqlite: createSqliteStore({ path: '.auth/state.sqlite', driver: 'auto' })
  },
  providers: {
    auth: 'sqlite',
    signal: 'sqlite',
    preKey: 'sqlite',
    session: 'sqlite',
    identity: 'sqlite',
    senderKey: 'sqlite',
    appState: 'sqlite',
    privacyToken: 'sqlite',
    messages: 'sqlite',
    threads: 'sqlite',
    contacts: 'sqlite'
  }
})

const client = new WaClient({ store, sessionId: 'default' }, logger)

client.on('auth_qr', ({ qr }) => console.log(qr))
client.on('connection', (event) => console.log('connection:', event.status, event.reason))

client.on('message', async (event) => {
  const text =
    event.message?.conversation ?? event.message?.extendedTextMessage?.text
  if (text?.trim().toLowerCase() !== 'ping') return
  await client.message.send(event.key.remoteJid, 'pong')
})

await client.connect()
```

<h2 id="whats-next">
  Próximos passos
</h2>

<CardGroup cols={2}>
  <Card title="Enviando mensagens" icon="paper-plane" href="/pt-br/guides/sending-messages" arrow>
    Respostas, menções, prévias de link e a union de conteúdo completa.
  </Card>

  <Card title="Recebendo mensagens" icon="inbox" href="/pt-br/guides/receiving-messages" arrow>
    Faça o parse dos eventos recebidos, envie recibos e descriptografe addons.
  </Card>

  <Card title="Reconexão" icon="arrows-rotate" href="/pt-br/guides/reconnection" arrow>
    O `zapo` não reconecta automaticamente — aqui está o padrão para lidar com isso.
  </Card>

  <Card title="Configuração" icon="sliders" href="/pt-br/concepts/configuration" arrow>
    Sessões, sincronização de histórico, timeouts, proxy e muito mais.
  </Card>
</CardGroup>