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

# Início Rápido

> Comece a usar o Triglit em 5 minutos

Este guia rápido vai te ajudar a fazer sua primeira integração com o Triglit.

## Pré-requisitos

* Conta no Triglit (obtenha em [triglit.com](https://triglit.com))
* Chaves de API (pública e/ou secreta)
* Node.js instalado (para usar o SDK JavaScript/TypeScript)

## Passo 1: Obter suas Chaves de API

1. Acesse o [Dashboard do Triglit](https://triglit.com/apps)
2. Navegue até **Configurações** → **API Keys**
3. Copie suas chaves:
   * **Chave Pública (pk\_...)** - Para uso no frontend
   * **Chave Secreta (sk\_...)** - Para uso no backend

<Warning>
  Nunca exponha sua chave secreta no frontend ou em repositórios públicos. Use apenas a chave pública no frontend.
</Warning>

## Passo 2: Instalar o SDK

Instale o SDK oficial do Triglit:

```bash theme={null}
npm install triglit
```

## Passo 3: Fazer sua Primeira Requisição

Vamos listar os triggers do seu tenant:

<CodeGroup>
  ```bash cURL theme={null}
  curl -X GET "https://api.triglit.com/v1/gateway/triggers" \
    -H "X-API-Key: pk_seu_token_aqui" \
    -H "Content-Type: application/json"
  ```

  ```javascript JavaScript theme={null}
  import Triglit from 'triglit';

  const client = new Triglit({ apiKey: 'pk_seu_token_aqui' });
  const triggers = await client.triggers.list();
  console.log(triggers);
  ```

  ```python Python theme={null}
  import requests

  headers = {
      'X-API-Key': 'pk_seu_token_aqui',
      'Content-Type': 'application/json'
  }

  response = requests.get(
      'https://api.triglit.com/v1/gateway/triggers',
      headers=headers
  )

  triggers = response.json()
  print(triggers)
  ```
</CodeGroup>

## Passo 4: Criar seu Primeiro Workflow

Vamos criar um workflow para processar pedidos:

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST "https://api.triglit.com/v1/gateway/workflows" \
    -H "X-API-Key: sk_seu_token_secreto_aqui" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Processar Pedido",
      "description": "Workflow para processar pedidos de clientes"
    }'
  ```

  ```javascript JavaScript theme={null}
  import Triglit from 'triglit';

  const client = new Triglit({ apiKey: 'sk_seu_token_secreto_aqui' });
  const workflow = await client.workflows.create({
    name: 'Processar Pedido',
    description: 'Workflow para processar pedidos de clientes'
  });
  console.log(workflow);
  ```

  ```python Python theme={null}
  import requests

  headers = {
      'X-API-Key': 'sk_seu_token_secreto_aqui',
      'Content-Type': 'application/json'
  }

  data = {
      'name': 'Processar Pedido',
      'description': 'Workflow para processar pedidos de clientes'
  }

  response = requests.post(
      'https://api.triglit.com/v1/gateway/workflows',
      headers=headers,
      json=data
  )

  workflow = response.json()
  print(workflow)
  ```
</CodeGroup>

## Passo 5: Criar uma Versão do Workflow

Agora vamos criar uma versão do workflow com nodes e edges:

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST "https://api.triglit.com/v1/gateway/workflow-versions" \
    -H "X-API-Key: sk_seu_token_secreto_aqui" \
    -H "Content-Type: application/json" \
    -d '{
      "workflowId": "workflow_id_aqui",
      "nodes": [
        {
          "id": "node-1",
          "type": "trigger_webhook",
          "config": {
            "path": "/pedido"
          }
        },
        {
          "id": "node-2",
          "type": "transform",
          "config": {
            "transformType": "expression",
            "expression": "{ ...input, status: \"processed\" }"
          }
        }
      ],
      "edges": [
        {
          "source": "node-1",
          "target": "node-2"
        }
      ]
    }'
  ```

  ```javascript JavaScript theme={null}
  import Triglit from 'triglit';

  const client = new Triglit({ apiKey: 'sk_seu_token_secreto_aqui' });
  const version = await client.workflows.versions.create({
    workflowId: 'workflow_id_aqui',
    nodes: [
      {
        id: 'node-1',
        type: 'trigger_webhook',
        config: {
          path: '/pedido'
        }
      },
      {
        id: 'node-2',
        type: 'transform',
        config: {
          transformType: 'expression',
          expression: '{ ...input, status: "processed" }'
        }
      }
    ],
    edges: [
      {
        source: 'node-1',
        target: 'node-2'
      }
    ]
  });
  console.log(version);
  ```

  ```python Python theme={null}
  import requests

  headers = {
      'X-API-Key': 'sk_seu_token_secreto_aqui',
      'Content-Type': 'application/json'
  }

  data = {
      'workflowId': 'workflow_id_aqui',
      'nodes': [
          {
              'id': 'node-1',
              'type': 'trigger_webhook',
              'config': {
                  'path': '/pedido'
              }
          },
          {
              'id': 'node-2',
              'type': 'transform',
              'config': {
                  'transformType': 'expression',
                  'expression': '{ ...input, status: "processed" }'
              }
          }
      ],
      'edges': [
          {
              'source': 'node-1',
              'target': 'node-2'
          }
      ]
  }

  response = requests.post(
      'https://api.triglit.com/v1/gateway/workflow-versions',
      headers=headers,
      json=data
  )

  version = response.json()
  print(version)
  ```
</CodeGroup>

## Passo 6: Criar um Trigger

Agora vamos criar um trigger para iniciar o workflow:

<CodeGroup>
  ```bash cURL theme={null}
  curl -X POST "https://api.triglit.com/v1/gateway/triggers" \
    -H "X-API-Key: sk_seu_token_secreto_aqui" \
    -H "Content-Type: application/json" \
    -d '{
      "workflowVersionId": "workflow_version_id_aqui",
      "type": "webhook",
      "isActive": true
    }'
  ```

  ```javascript JavaScript theme={null}
  import Triglit from 'triglit';

  const client = new Triglit({ apiKey: 'sk_seu_token_secreto_aqui' });
  const trigger = await client.triggers.create({
    workflowVersionId: 'workflow_version_id_aqui',
    type: 'webhook',
    isActive: true
  });
  console.log(trigger);
  ```

  ```python Python theme={null}
  import requests

  headers = {
      'X-API-Key': 'sk_seu_token_secreto_aqui',
      'Content-Type': 'application/json'
  }

  data = {
      'workflowVersionId': 'workflow_version_id_aqui',
      'type': 'webhook',
      'isActive': True
  }

  response = requests.post(
      'https://api.triglit.com/v1/gateway/triggers',
      headers=headers,
      json=data
  )

  trigger = response.json()
  print(trigger)
  ```
</CodeGroup>

## Próximos Passos

<CardGroup cols={2}>
  <Card title="Conceitos Fundamentais" icon="book" href="/concepts/workflows">
    Aprenda sobre workflows, nodes e triggers
  </Card>

  <Card title="Referência da API" icon="code" href="/api-reference/introduction">
    Explore todos os endpoints disponíveis
  </Card>

  <Card title="Guias de Integração" icon="plug" href="/guides/integration">
    Veja exemplos práticos de integração
  </Card>

  <Card title="Custom Nodes" icon="puzzle-piece" href="/guides/custom-nodes">
    Crie nodes personalizados para seus workflows
  </Card>
</CardGroup>

<Tip>
  Use a chave pública (pk\_) no frontend e a chave secreta (sk\_) no backend. A chave secreta tem mais permissões e deve ser mantida em segurança.
</Tip>