Resumo rápido
- O Code da Pluga permite adicionar blocos de código dentro do construtor de automatizações, em qualquer posição (gatilho e ação) e em duas linguagens (Python e JavaScript).
- Os gatilhos “Executar Python” e “Executar JavaScript” são os pontos de partida da automatização: você escreve um script, declara os campos de saída, e esses campos viram atributos mapeáveis nas etapas seguintes.
- Ações “Executar Python” e “Executar JavaScript” podem ser inseridas em qualquer posição depois do gatilho. Elas recebem dados mapeados de etapas anteriores, processam, e podem ou não devolver dados de saída (outputs) para o restante do fluxo.
- O Code cobre três casos de uso: conexão a APIs sem integração nativa, transformações avançadas de dados que o Formatador não resolve, e regra de negócio proprietária (cálculos, pontuações e decisões determinísticas).
Sobre o Code
O recurso tem dois eixos:
- Posição no fluxo: pode ser o gatilho, que inicia a automatização, ou uma ação, que processa dados no meio ou no fim do caminho. A versão de ação pode ser inserida em qualquer ponto após o gatilho.
- Linguagem: Python ou JavaScript, atendendo tanto quem já escreve Python quanto o perfil front-end ou fullstack que domina JS. O comportamento é idêntico entre as duas: muda só a sintaxe.
Em ambos os casos, a saída funciona do mesmo jeito: você declara os campos que o script retorna, e esses campos ficam disponíveis como atributos para serem utilizados no mapeamento adiante.
Code como gatilho
O script é executado e seus outputs declarados alimentam o restante do fluxo. Serve para iniciar uma automação a partir de uma fonte que a Pluga não integra nativamente, como por exemplo buscar dados em uma API e então gerar (ou até mesmo calcular) dados por conta própria.
1. Adicionar o gatilho de Code
Adicione o gatilho de Code como início da automatização e escolha a linguagem desejada.
2. Escrever o script
Por exemplo, uma consulta à API do Banco Central para verificar o valor do dólar.
3. Declarar os dados de saída
Esses atributos são os que poderão ser mapeados adiante.
4. Consumir os atributos nas etapas seguintes
As etapas seguintes consomem esses atributos como qualquer outro dado de gatilho.
Code como ação
Extremamente útil para transformar dados, aplicar lógicas personalizadas (score, fórmula, rateio, decisão) com total controle, ou montar e entregar uma requisição para um sistema.
📌 A ação do Code também pode ser salva sem gerar nenhum dado de saída dentro da Pluga. Nesse caso, o script faz o que precisa fazer (por exemplo, um POST para uma API externa) e o fluxo termina ali mesmo. Esse é o padrão “Code como entrega final”: quando o resultado da automatização é o efeito que o script provoca no sistema externo, e o Code não precisa retornar um dado que seguirá adiante.
1. Inserir a etapa de Code
A etapa pode entrar em qualquer ponto após o gatilho.
2. Declarar os dados de entrada
Antes de escrever o script, defina quais dados quer usar. Isso acontece nos ajustes dos “Dados de entrada”, onde cada dado tem um nome (a chave) e um valor, que vem mapeado de uma etapa anterior do fluxo.
3. Escrever o script
Redija o script, utilizando os dicionários input_data (Python) ou inputData (JavaScript) para utilizar os dados de entrada. Exemplo:
| Python | JavaScript |
|---|---|
nome = input_data['nome_cliente']valor = input_data['valor_pedido'] | const nome = inputData.nome_cliente;const valor = inputData.valor_pedido; |
Supondo que você queira separar apenas o primeiro nome do cliente e normalizar os valores para o padrão esperado pela ferramenta de destino, chame as chaves de entrada no script e dê os comandos para as ações desejadas.
4. Declarar os dados de saída (outputs)
No exemplo, os dados de saída configurados no código são primeiro_nome e valor_pedido_normalizado. Esses serão os atributos que poderão ser mapeados nas próximas etapas.
5. Mapear na etapa seguinte
💡 Importante: todos os valores chegam ao Code como texto
Não importa se o campo de origem é um número, uma data ou um booleano: o que entra no script é sempre uma string de texto. Para operar matematicamente, é preciso converter o dado explicitamente.
Python
valor_num = float(input_data['valor_pedido'])
desconto_num = float(input_data['desconto'])
valor_final = valor_num * (1 - desconto_num / 100) JavaScript
const valorNum = Number(inputData.valor_pedido);
const descontoNum = Number(inputData.desconto);
const valorFinal = valorNum * (1 - descontoNum / 100); Por que usar o Code da Pluga
Com o Code, você multiplica infinitamente os poderes das suas automatizações:
- Origem sem app nativo: o gatilho de Code transforma qualquer API aberta em possível gatilho de uma automatização.
- Transformação e lógica sob medida: a ação de Code resolve casos de formatação e outros recursos em uma só operação, como adição de datas e operações matemáticas, eliminando fluxos com múltiplas etapas de formatação, planilhas intermediárias ou encadeamento de automatizações.
- Entrega a sistemas fechados: o script pode montar e enviar uma requisição para sistemas mais fechados.
Code na Pluga
O Code não substitui outros recursos da Pluga, como HTTP Requests, formatadores e componentes de IA. Ele os complementa para casos de uso mais técnicos ou que exijam controle fino sobre os dados.
| Se você precisa | Caminho alternativo | Quando usar o Code |
|---|---|---|
| Chamar uma API | HTTP Request (chamada direta) | Quando é preciso montar o payload, tratar a resposta ou condicionar a chamada com uma lógica específica. |
| Formatar dados | Formatador (data, número, texto, casos prontos) | Quando a transformação é mais profunda que as opções do formatador: extrações customizadas, manipulação de arrays ou strings fora do padrão. |
| Classificar, resumir, extrair de texto solto | Kit de IA, Claude, ChatGPT, Gemini | Quando a regra é determinística (mesma entrada gera sempre a mesma saída), sem espaço para interpretação. Num mesmo fluxo dá para usar os dois: a IA interpreta, o Code executa a regra exata sobre o resultado. |
| Decisão autônoma e multi-ferramenta | Agente de IA | Quando a regra é fixa e conhecida, e não precisa de autonomia. |
Combinação com outras ferramentas de workflow da Pluga
- Loop: itera uma lista e roda o Code para cada item, aplicando um cálculo proprietário item a item.
- Roteador: o Code calcula um valor ou categoria, e o Roteador encaminha para a rota correta com base no valor retornado.
O que é possível fazer com o Code
- Formatar texto: maiúsculas, minúsculas, trim, split, join.
- Calcular valores: operações matemáticas, porcentagens, arredondamentos.
- Extrair partes de uma string: substr, regex, split por separador.
- Construir strings compostas a partir de múltiplos inputs.
- Converter formatos: string para número, número para string formatada.
- Consultar APIs externas e retornar o resultado como campo de saída.
- Enviar dados a um endpoint externo.
- Consultar APIs públicas: CEP, CNPJ, cotação de moeda.
- Aplicar lógica condicional.
Scripts de exemplo
Separar nome completo em partes
Entrada: um único campo com o nome completo. Saída: primeiro nome, nomes do meio agrupados e último nome. Campos de output: primeiro_nome, nomes_do_meio, ultimo_nome.
Python
partes = input_data['nome_completo'].strip().split()
if len(partes) == 0:
return {'primeiro_nome': '', 'nomes_do_meio': '', 'ultimo_nome': ''}
elif len(partes) == 1:
return {'primeiro_nome': partes[0], 'nomes_do_meio': '', 'ultimo_nome': ''}
elif len(partes) == 2:
return {'primeiro_nome': partes[0], 'nomes_do_meio': '', 'ultimo_nome': partes[1]}
else:
return {
'primeiro_nome': partes[0],
'nomes_do_meio': ' '.join(partes[1:-1]),
'ultimo_nome': partes[-1]
} JavaScript
const partes = inputData.nome_completo.trim().split(' ').filter(p => p.length > 0);
if (partes.length === 0) return { primeiro_nome: '', nomes_do_meio: '', ultimo_nome: '' };
if (partes.length === 1) return { primeiro_nome: partes[0], nomes_do_meio: '', ultimo_nome: '' };
if (partes.length === 2) return { primeiro_nome: partes[0], nomes_do_meio: '', ultimo_nome: partes[1] };
return {
primeiro_nome: partes[0],
nomes_do_meio: partes.slice(1, -1).join(' '),
ultimo_nome: partes[partes.length - 1]
}; Limpar e normalizar CPF, CNPJ ou telefone
Remove tudo que não é número. Útil antes de enviar para ERPs e sistemas que esperam o campo limpo. Campo de output: documento_limpo.
Python
documento = input_data['documento']
documento_limpo = documento.replace('.', '').replace('-', '').replace('/', '').replace(' ', '')
return {
'documento_limpo': documento_limpo
} JavaScript
return {
documento_limpo: inputData.documento.replace(/\D/g, '')
}; Calcular valor com desconto e formatação
Campos de output: valor_final (Número) e valor_formatado (Texto).
Python
valor = float(input_data['valor_bruto'])
desconto_pct = float(input_data['desconto_pct'])
final = round(valor * (1 - desconto_pct / 100), 2)
return {
'valor_final': final,
'valor_formatado': f"R$ {final:,.2f}".replace(',', 'X').replace('.', ',').replace('X', '.')
} Lookup table: converter código em texto
Quando um sistema de origem retorna um código numérico ou abreviação e o destino espera o texto completo. Campo de output: status_texto.
Python
mapa = {
'1': 'Aprovado',
'2': 'Pendente',
'3': 'Recusado',
'4': 'Reembolsado'
}
codigo = input_data['status_codigo'].strip()
return {
'status_texto': mapa.get(codigo, 'Status desconhecido')
} JavaScript
const mapa = {
'1': 'Aprovado',
'2': 'Pendente',
'3': 'Recusado',
'4': 'Reembolsado'
};
return {
status_texto: mapa[inputData.status_codigo.trim()] || 'Status desconhecido'
}; Consultar API externa e retornar campos
Padrão para qualquer consulta HTTP. O exemplo usa o ViaCEP, mas o mesmo modelo se aplica a qualquer API de enriquecimento. Campos de output: logradouro, bairro, cidade, uf.
Python
cep = input_data['cep'].replace('-', '').replace('.', '').strip()
url = f"https://viacep.com.br/ws/{cep}/json/"
resposta = requests.get(url, timeout=5)
if resposta.status_code != 200:
return {'logradouro': '', 'bairro': '', 'cidade': '', 'uf': ''}
dados = resposta.json()
if dados.get('erro'):
return {'logradouro': '', 'bairro': '', 'cidade': '', 'uf': ''}
return {
'logradouro': dados.get('logradouro', ''),
'bairro': dados.get('bairro', ''),
'cidade': dados.get('localidade', ''),
'uf': dados.get('uf', '')
} Montar payload para POST em API externa
Quando o script precisa enviar dados para um sistema sem conector nativo, não apenas buscar. Sem campos de output declarados: o script só executa o POST.
Python
payload = {
'cliente': input_data['nome_cliente'],
'documento': input_data['cnpj'],
'valor': float(input_data['valor']),
'referencia': input_data['numero_pedido']
}
headers = {
'Authorization': f"Bearer {input_data['token']}"
}
resposta = requests.post(
'https://api.sistema-interno.com.br/pedidos',
headers=headers,
json=payload,
timeout=10
)
resposta.raise_for_status() Veja também: 15 scripts prontos para copiar e usar no Code da Pluga (Python e JavaScript)
Casos de uso
Software e Cloud
Consumir API interna ou que não tenha um conector na Pluga como gatilho ou ação; parsear payloads customizados de webhooks; aplicar lógicas determinísticas.
RevOps e Operações
Cálculos sob medida (score de lead, comissão, rateio); normalização de dados entre sistemas com formatos diferentes.
E-commerce
Tratamento de payload de pedido (arrays de produtos, strings fora do padrão); enriquecimento com API externa (frete, CEP, validação) antes de mandar para o ERP.
Financeiro
Cálculo proprietário (imposto, conversão customizada, rateio) antes de lançar no ERP ou emitir nota; validação de dados antes de executar o registro contábil.
Agências
Integração sob medida para o cliente (API de nicho que só aquele cliente usa); lógica específica por conta.
Automatizações prontas com Code
Cinco fluxos completos para copiar, do gatilho em API sem conector à entrega em sistema fechado.
Template 1
API sem gatilho nativo na Pluga
Iniciar uma automatização a partir de uma API que a Pluga não integra nativamente.
- 1 Code | Gatilho: executar Python. Usa
requestspara buscar dados de uma API sem conector nativo e declara os campos de saída. - 2 Google Sheets ou Trello | Inserir linha ou criar card. Registra cada retorno da API na ferramenta de destino.
Template 2
Normalização de payload de e-commerce antes do ERP
Normalizar CPF, CEP e datas para entregar os dados limpos ao ERP.
- 1 Nuvemshop ou Shopify | Gatilho: pedido criado. Retorna os dados do pedido.
- 2 Code | Ação: executar Python. Parseia e normaliza a estrutura, limpa strings, converte tipos.
- 3 Conta Azul ou Bling | Criar registro. Recebe os dados limpos.
Template 3
Score de lead com regra proprietária e Roteador
Qualificar com lógica determinística, sem margem interpretativa.
- 1 Typeform, RD Station Marketing ou Facebook Lead Ads | Gatilho: novo lead. Retorna os dados do lead.
- 2 Code | Ação: executar JavaScript. Calcula um score com fórmula própria e retorna número e categoria.
- 3 Roteador | Correspondência única. Direciona por faixa de pontuação.
- 4 Pipedrive, RD Station CRM ou Agendor | Cadastrar no CRM. Encaminha cada lead de forma diferente.
Template 4
Cálculo proprietário por item, com Loop
Aplicar uma regra de cálculo item a item dentro de um fluxo de vendas.
- 1 RD Station CRM | Gatilho: negócio ganho. Retorna o deal com a lista de produtos.
- 2 Loop | Iterar sobre produtos. As etapas seguintes rodam para cada item.
- 3 Code | Ação: executar Python. Calcula comissão, imposto ou rateio do item com regra própria.
- 4 Google Sheets | Inserir linha. Registra cada item com o valor calculado.
Template 5
Extrair dados de um webhook
Tratar dados vindos de eventos ocorridos em sistemas internos com lógica customizada, sem servidor externo.
- 1 Webhooks | Gatilho: notificação recebida. Recebe o payload de um sistema interno.
- 2 Code | Ação: executar JavaScript. Parseia o payload, extrai os campos e valida.
- 3 Notion, Supabase ou Slack | Registrar ou notificar. Grava ou avisa com os dados tratados.