O Code é uma funcionalidade da Pluga permite escrever scripts em Python ou JavaScript direto dentro da sua automatização, abrindo uma série de possibilidades que antes não existiam ou exigiam múltiplas etapas e configurações: consultar uma API específica, aplicar uma regra de cálculo que só faz sentido no seu negócio, padronizar diversos dados que chegam da origem fora do formato ideal.

O único porém é que, nem todo mundo sabe como redigir um script do zero. Por isso, reunimos aqui 15 scripts que já estão rodando em automatizações reais , organizados por tipo de problema que resolvem. Alguns você já pode copiar, colar e sair usando. Outros pedem um ajuste de duas ou três linhas pra se encaixar perfeitamente na sua realidade. Todos foram testados dentro da Pluga, então pode confiar. Vamos nessa?

Como usar os scripts deste artigo

Antes de mais nada, vale entender o padrão de comportamento e configuração do Code na Pluga. Funciona assim:

  1. Você declara os dados de entrada (inputs).

    Cada campo tem um nome (a gente chama de chave) e recebe um valor que vem de uma etapa anterior do seu fluxo. É o que aparece ali no painel “Dados de entrada” do bloco.

  2. Dentro do script, você acessa esses campos com um dicionário fixo:

    Em Python, pelo dicionário input_data['nome_do_campo']
    Em JavaScript, pelo objeto inputData.nome_do_campo

  3. Você declara os campos de saída (outputs)

    Antes de rodar, você diz quais campos o script vai devolver e de que tipo eles são. Só o que você declarar aqui vai aparecer disponível pra usar nas próximas etapas.

  4. Um detalhe que evita 90% dos erros:

    Nem todo valor chega como texto (string). Não importa se lá na origem era número, data ou verdadeiro/falso: quando entra no script, vira texto. Então, se você for fazer conta com os dados, converta antes:

    Pythonvalor = float(input_data[‘valor_pedido’])

    Pythonvalor = float(input_data[‘valor_pedido’])


    Guarde essa dica no bolso, porque ela vai aparecer de novo mais pra frente. Em cada script abaixo, a gente indica quais campos você precisa ter na entrada e quais declarar na saída. O resto é copiar, colar e conectar as pontas.

Não sabe programar? Gere o Script com IA

Você não precisa saber Python ou JavaScript pra usar o Code. Uma opção que funciona muito bem é pedir pra uma IA (ChatGPT, Claude, Gemini) gerar o script pra você, desde que a IA saiba as regras específicas do Code da Pluga. Se você mandar só “faz um script que soma dois números”, ela vai chutar uma sintaxe qualquer e o script não vai funcionar.

Abaixo, seguem dois modelos de prompt para você copiar e colar na IA para obter um script da maneira que o Code da Pluga espera receber. Copie, preencha os espaços em branco e cole na sua IA de preferência.

Modelo de prompt para gerar os scripts em Python:

PromptPreciso de um código em Python 3 que será executado dentro de uma etapa de automação. Use o dicionário ‘input_data’ para acessar os dados de entrada e retorne um dicionário com os dados de saída, que será usado nas próximas etapas.Importante: todos os valores em ‘input_data’ chegam como string. Se precisar fazer conta, converta com float() ou int() antes.O que quero que o código faça:[descreva em uma frase o que o script precisa resolver]Campos de entrada que estarão disponíveis em input_data:– [nome_do_campo_1]: [o que é / exemplo do valor]– [nome_do_campo_2]: [o que é / exemplo do valor]Campos de saída que preciso que o retorno tenha:– [nome_do_campo_saida_1]: [o que é / tipo]– [nome_do_campo_saida_2]: [o que é / tipo]

Modelo de prompt para gerar os scripts em JavaScript:

PromptPreciso de um código em JavaScript (Node.js 24) que será executado dentro de uma etapa de automação. Use o objeto ‘inputData’ para acessar os dados de entrada e retorne um objeto com os dados de saída, que será usado nas próximas etapas.Importante: todos os valores em ‘inputData’ chegam como string. Se precisar fazer conta, converta com Number() antes.O que quero que o código faça:[descreva em uma frase o que o script precisa resolver]Campos de entrada que estarão disponíveis em inputData:– [nome_do_campo_1]: [o que é / exemplo do valor]– [nome_do_campo_2]: [o que é / exemplo do valor]Campos de saída que preciso que o retorno tenha:– [nome_do_campo_saida_1]: [o que é / tipo]– [nome_do_campo_saida_2]: [o que é / tipo]

Uma vez que o script sair da IA, cole no bloco Code, declare os campos de entrada e saída que você pediu no prompt, e teste. O resultado costuma sair certo na primeira tentativa, mas se der erro, cole a mensagem de erro de volta pra IA para ela corrigir o script.

Scripts para trabalhar com leads

Todo mundo que capta leads conhece essa história: os contatos chegam de vários lugares diferentes, como Facebook Lead Ads, formulário do site, landing pages de campanhas específicas, etc. E cada canal manda os dados do lead do seu próprio jeito. Um vem com o telefone certinho, o outro sem DDD, o outro com o estado escrito por extenso… uma bagunça. Os quatro scripts a seguir organizam e padronizam esses dados antes deles entrarem no seu CRM.

1. Limpar telefone e adicionar o DDI +55

O que resolve: sabe quando o telefone chega cheio de parênteses, hífen, espaço e ainda sem o código do país? Este script limpa tudo isso e deixa só os números, com o +55 já na frente.

Quando faz sentido: em qualquer fluxo eque envie automaticamente uma mensagem de WhatsApp para o lead ou cadastrá-lo em um um CRM que exige o formato internacional.

Pythonphone = input_data[‘phone’]phone = ”.join(filter(str.isdigit, phone))if len(phone) >= 11:phone = ’55’ + phonereturn {‘telefone’: phone}

2. Converter o nome do estado em sigla (UF)

O que resolve: o lead escreve “São Paulo” (ou Sao Paulo) no formulário, mas o seu CRM só entende “SP”. Este script pega qualquer variação (com acento, sem acento, maiúscula, minúscula) e devolve a sigla certa. E se o dado já chegar como “SP”, ele simplesmente mantém.

Quando faz sentido: na captura de leads pelo Facebook Lead Ads, em formulários abertos e naquelas integrações com bases antigas que ninguém padronizou.

JavaScriptconst estados = {“acre”:”AC”,”alagoas”:”AL”,”amapa”:”AP”,”amapá”:”AP”,“amazonas”:”AM”,”bahia”:”BA”,”ceara”:”CE”,”ceará”:”CE”,“distrito federal”:”DF”,”espirito santo”:”ES”,”espírito santo”:”ES”,“goias”:”GO”,”goiás”:”GO”,”maranhao”:”MA”,”maranhão”:”MA”,“mato grosso”:”MT”,”mato grosso do sul”:”MS”,”minas gerais”:”MG”,“para”:”PA”,”pará”:”PA”,”paraiba”:”PB”,”paraíba”:”PB”,“parana”:”PR”,”paraná”:”PR”,”pernambuco”:”PE”,”piaui”:”PI”,“piauí”:”PI”,”rio de janeiro”:”RJ”,”rio grande do norte”:”RN”,“rio grande do sul”:”RS”,”rondonia”:”RO”,”rondônia”:”RO”,“roraima”:”RR”,”santa catarina”:”SC”,”sao paulo”:”SP”,“são paulo”:”SP”,”sergipe”:”SE”,”tocantins”:”TO”};const valorOriginal = inputData.estado ?? inputData.state ?? “”;const valor = String(valorOriginal).trim().toLowerCase();const siglas = new Set(Object.values(estados));const sigla = siglas.has(valor.toUpperCase())? valor.toUpperCase(): (estados[valor] || “”);return {state: sigla};

3. Separar o nome completo em primeiro, nome do meio e sobrenome

O que resolve: a ferramenta de origem ou API entrega o nome do lead em um campo único de “nome completo”, mas o app de destino pede primeiro nome, nome do meio e sobrenome separados. O script faz essa divisão e ainda dá conta dos casos complicados (por exemplo, quando a pessoa põe só o primeiro nome, quando tem nome composto ou até quando tem vários nomes do meio).

Quando faz sentido: na ponte entre formulários abertos (Google Forms, Typeform) e CRMs mais estruturados, como RD Station CRM, Pipedrive ou HubSpot.

Pythonpartes = 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]}

Prefere JavaScript? Você consegue obter o mesmo resultado assim:

JavaScriptconst 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]};

4. Gerar hash de e-mail e telefone para APIs de conversão

O que resolve: as APIs de conversão da Meta, do Google Ads, do TikTok Ads e de outras plataformas de anúncio exigem que dados pessoais, como e-mail e telefone, sejam enviados anonimizados por um hash SHA-256. Parece complicado, mas este script normaliza os dados e gera esses hashes pra você sem esforço.

Quando faz sentido: para quem roda campanhas de conversão e precisa devolver os dado de leads que converteram em eventos (uma venda, um cadastro, uma oportunidade) pras plataformas, ajudando os anúncios a performarem melhor.

Pythonimport hashlibimport refrom datetime import datetime, timezonedef sha256(value):if not value:return ”return hashlib.sha256(value.encode(‘utf-8’)).hexdigest()def normalize_email(email):if not email:return ”return str(email).strip().lower()def normalize_phone(phone):if not phone:return ”phone = re.sub(r’\D’, ”, str(phone))if not phone.startswith(’55’):phone = ’55’ + phonereturn phoneemail = normalize_email(input_data.get(‘email’))phone = normalize_phone(input_data.get(‘phone’) or input_data.get(‘telefone’))event_time = int(datetime.now(timezone.utc).timestamp())return {‘email_hash’: sha256(email),‘phone_hash’: sha256(phone),‘event_time’: event_time}

Depois do Code, você usa um bloco de requisição HTTP ou, por exemplo, a integração nativa da Pluga com o Facebook Custom Audiences pra mandar esses dados pra plataforma de anúncios. O melhor: os dados pessoais nunca trafegam abertos.

Scripts para financeiro e cobranças

Se tem um lugar onde o Code pode fazer uma diferença de peso, é no financeiro. Cálculos de taxas, descontos, impostos, comissões: todas essas são situações em que você precisa que o mesmo dado de entrada gere sempre exatamente o mesmo resultado, sem espaço pra interpretação ou surpresa. Os quatro scripts abaixo cobrem os cenários mais comuns do dia a dia.

5. Aplicar a taxa certa conforme o número de parcelas

O que resolve: o meio de pagamento opera taxas diferentes dependendo da faixa de parcelamento: uma porcentagem pra pagamento à vista, outra de 2 a 6 vezes, outra acima disso. O seu sistema de cobrança não conhece essa regra, porque ela diz respeito a uma negociação particular da sua empresa. Este script aplica a conta automaticamente.

Onde faz sentido: em e-commerces com várias opções de pagamento, em BPOs financeiros que cuidam da operação de vários clientes e em infoprodutores que precisam fechar a conciliação todo mês.

Pythonparcelas = int(input_data[‘parcelas’])if parcelas == 1:taxa = ‘3.63%’elif 2

Aquele truque com o .replace('X') no final serve só pra virar o formato americano (1,234.56) no nosso jeito de escrever (1.234,56). Pequeno detalhe que faz toda a diferença.

7. Limpar CPF, CNPJ ou telefone (deixar só os números)

O que resolve: o dado chega cheio de pontos, traços, barras e espaços, mas o seu sistema só quer os números limpos. Este é um script curtinho que serve pra qualquer campo numérico que venha com formatação decorativa.

Onde faz sentido: antes de registrar qualquer coisa no ERP, na hora de emitir uma nota ou de consultar uma API de validação.

Pythondocumento = input_data[‘documento’]documento_limpo = documento.replace(‘.’, ”).replace(‘-‘, ”).replace(‘/’, ”).replace(‘ ‘, ”)return {‘documento_limpo’: documento_limpo}

Se você curte JavaScript, dá pra resolver em uma linha só:

JavaScriptreturn {documento_limpo: inputData.documento.replace(/\D/g, ”)};

8. Traduzir um código de status em texto legível

O que resolve: alguns sistemas e APIs de nicho adoram devolver o status como um número (1, 2, 3, 4). O problema é que ninguém quer ver “3” no relatório, mas sim ver “Aprovado” ou “Recusado” – por exemplo. Este script faz essa tradução pra você.

Onde faz sentido: em integrações com CRMs, ERPs, gateways de pagamento que respondem com códigos e em importações de sistemas internos.

Pythonmapa = {‘1’: ‘Aprovado’,‘2’: ‘Pendente’,‘3’: ‘Recusado’,‘4’: ‘Reembolsado’}codigo = input_data[‘status_codigo’].strip()return {‘status_texto’: mapa.get(codigo, ‘Status desconhecido’)}

E em JavaScript:

JavaScriptconst mapa = {‘1’: ‘Aprovado’,‘2’: ‘Pendente’,‘3’: ‘Recusado’,‘4’: ‘Reembolsado’};return {status_texto: mapa[inputData.status_codigo.trim()] || ‘Status desconhecido’};

Basta trocar o mapa pelos códigos e status que o seu sistema usa. O mesmo padrão vale pra qualquer tradução fixa de um valor em outro.

Scripts para e-commerces e ERPs

Se tem uma coisa que costuma vir fora do padrão, é o dado de e-commerce e ERP: arrays dentro de arrays, IDs que só fazem sentido dentro de cada sistema, JSON que quase funciona. Os três scripts a seguir domam justamente esses casos.

9. Formatar o CNPJ no padrão 00.000.000/0000-00

O que resolve: o CNPJ chega só com os 14 números, ou formatado pela metade, e você quer ele “bonitinho” no padrão brasileiro, com pontos, barra e hífen .

Onde faz sentido: em notas fiscais, contratos, cadastros em sistemas e relatórios que vão parar na mão do cliente.

Javascriptconst formatarCnpj = (cnpj) => {const digitos = cnpj.replace(/\D/g, ”);return digitos.replace(/^(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})$/,‘$1.$2.$3/$4-$5’);};return {cnpj_formatado: formatarCnpj(inputData.cnpj)};

10. Extrair campos por ID de um dado complexo

O que resolve: muitos sistemas de gestão devolvem os campos personalizados como uma lista de objetos com IDs numéricos, tipo [{campo_extra_id: 71097, valor: "avista"}, ...]. O problema é que a ordem nem sempre é a mesma, então você não consegue mapear direto. Este script busca cada campo pelo ID e entrega tudo com um nome legível.

Onde faz sentido: em integrações com ERPs e CRMs que trabalham com “campos personalizados” ou “campos extras” e vários sistemas internos seguem esse formato.

Javascriptconst { inputEmail, inputTelefone, inputExtras } = inputData;const [email] = inputEmail;const [telefone] = inputTelefone;const parsedExtras = JSON.parse(inputExtras);const dicionarioCampos = {cobranca: 71097,origem: 71067,tipoFrete: 70863,tipoCarga: 71068,produto: 72635,pedidoErp: 70861};const valorPorIdCampo = (extras, campoId) => {const campo = extras.find((e) => e.campo_extra_id === campoId);if (!campo) return null;if (campo.tipo === ‘0’) return campo.valor;return campo.valor?.[0]?.[1] ?? null;};const valoresCampos = Object.fromEntries(Object.entries(dicionarioCampos).map(([nome, id]) => [nome,valorPorIdCampo(parsedExtras, id)]));return {email,telefone,…valoresCampos};

O ajuste aqui é trocar o dicionarioCampos pelos IDs dos campos extras do seu sistema. Os nomes ficam a seu critério para você usar aqueles que fizerem sentido pra sua operação.

11. Consertar um JSON malformado antes de ler

O que resolve: algumas APIs podem retornar um texto que é quase um JSON válido, mas precisa de ajustes finos: faltam aspas nas chaves, como por exemplo aparecer nil no lugar de null. Este script arruma os erros mais comuns antes de tentar interpretar o conteúdo.

Onde faz sentido: em webhooks de sistemas internos, APIs legadas e integrações em que você não tem controle sobre como o dado sai da origem.

Pythonimport reimport jsontags_str = input_data[‘tags’]tags_str = tags_str.replace(‘”‘, ‘”‘)tags_str = re.sub(r'([{,]\s*)(\w+):’, r’\1″\2″:’, tags_str)tags_str = tags_str.replace(‘: nil’, ‘: null’)tags = json.loads(tags_str)labels = ‘, ‘.join(tag[‘label’] for tag in tags)return {‘tags_formatadas’: labels}

Esse é aquele tipo de script que resolve um problema que nenhum formatador pronto consegue resolver. Afinal, cada JSON “malformado é “bagunçado” “desorganizado” tem seu próprio jeito. Então aqui o Code brilha de verdade.

Scripts para conectar com APIs e webhooks

Agora chegamos na função em que o Code mostra todo o seu potencial: virar uma ponte entre a Pluga e qualquer sistema que tenha uma API, mesmo aqueles que ainda não têm um conector pronto por aqui.

12. Consultar o CEP no ViaCEP e trazer o endereço completo

O que resolve: o cliente informou só o CEP e você quer preencher automaticamente a rua, o bairro, a cidade e o estado antes de mandar tudo pro CRM ou pro ERP. Este script consulta o ViaCEP e traz o endereço completo.

Onde faz sentido: no cadastro de clientes em e-commerces, imobiliárias, entregas locais ou em qualquer fluxo que precise do endereço a partir do CEP.

Pythoncep = 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’, ”)}

E o melhor: esse mesmo padrão serve pra qualquer API pública de consulta. Ou seja: para buscar dados de um CNPJ na Receita, a cotação do dólar no Banco Central ou validar um e-mail é só trocar a URL e ajustar os campos que você quer no retorno.

13. Enviar dado para uma API

O que resolve: você precisa mandar um dado (como um lead, um pedido, um evento) pra um sistema interno da empresa ou pra um SaaS de nicho que a Pluga ainda não integra nativamente. Aqui o Code entra atuando como entrega final: ele monta a requisição, faz o envio e encerra o fluxo ali mesmo.

Onde faz sentido: com sistemas internos da empresa, ERPs regionais e plataformas mais específicas do seu setor.

Pythonpayload = {‘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)

Troque a URL, o conteúdo do payload e os headers pelo que a sua API espera.

14. Pegar um campo específico de um JSON recebido por webhook

O que resolve: chega um webhook com um JSON enorme, mas você só precisa de um campo lá do meio. Em vez de configurar mil variáveis, este script pega só o que interessa e ignora o resto.

Onde faz sentido: em notificações de plataformas de pagamento, eventos de sistemas internos e webhooks de plataformas de curso e infoproduto.

Campos de entrada esperados: x (o JSON completo como texto). Campos de saída para declarar: o campo que você quer extrair (no exemplo, produto).

Pythonimport jsondata = json.loads(input_data[‘x’])return {‘produto’: data[‘produto’]}}

Simples assim. E se o campo estiver aninhado lá no fundo, é só ir descendo os níveis (algo como data['pedido']['produto']['nome']).

15. Juntar uma lista de tags numa frase só

O que resolve: você recebe uma lista de tags como um monte de objetos JSON, mas quer só uma frase única, separada por vírgulas, pra colocar num campo de texto do CRM, mandar por e-mail ou registrar numa planilha. Este script faz essa junção.

Onde faz sentido: em integrações com plataformas de atendimento, como Digisac e Zendesk, e com sistemas que tratam tags como objetos cheios de metadados.

Pythonimport jsontags_str = input_data[‘tags’]tags = json.loads(tags_str)labels = ‘, ‘.join(tag[‘label’] for tag in tags)return {‘tags_formatadas’: labels}

Se as tags chegarem como [{"label":"Cliente"}, {"label":"VIP"}] , elas saem prontinhas assim: Cliente, VIP.

Combine o Code com outras funcionalidades

O Code fica ainda mais interessante quando trabalha junto com outras ferramentas integradas à Pluga. Dá só uma olhada em algumas combinações que rendem muito:

Code + Roteador: o Code calcula um score, uma categoria ou um nível (usando qualquer um dos scripts 5, 6, 7 ou 8, por exemplo) e o Roteador manda o fluxo pra um caminho diferente conforme o resultado. Lead nota A vai direto pro vendedor sênior, o B entra na régua de nutrição, o C segue pra outro destino.

Code + Loop: o Code monta uma lista de itens (como por exemplo os produtos de um pedido) e o Loop roda os próximos passos um a um pra cada item. Ótimo pra calcular comissão item por item, gerar linhas separadas no ERP ou enviar coisas individualmente.

Para não esquecer

Preciso saber Python ou JavaScript pra usar o Code?

Não precisa! Você pode gerar o script com uma IA, ou simplesmente copiar um dos 15 scripts prontos e ajustar só os nomes dos campos de entrada e saída.

Python ou JavaScript: qual eu escolho?

As duas linguagens funcionam igualzinho dentro do Code. Escolha a que você (ou quem for cuidar do script depois) se sente mais à vontade. Se está começando do zero, muita gente acha o Python um pouco mais fácil.

Meu cálculo está dando erro. O que pode ser?

Na maioria das vezes diz respeito ao tratamento do dado: todos os valores chegam como texto, mesmo quando são números na origem. Então, antes de fazer qualquer conta, converta o valor com float() ou int() no Python, ou Number() no JavaScript. Esse ajuste costuma resolver o problema.

Posso ter uma etapa Code sem declarar nenhum campo de saída?

Pode, sim. Quando o script só envia dados pra um sistema externo (como aquele POST do script 13) e não precisa devolver nada pro fluxo, é só deixar os campos de saída em branco. O fluxo se encerra ali mesmo.

Agora é a sua vez

Escolha um dos 15 scripts que resolve um probleminha que já te incomoda hoje (aquele lead que sempre chega bagunçado, a taxa que você calcula na mão toda semana, a API que ninguém integrava). Cole no Code, ajuste os campos e teste. Em poucos minutos, aquele “e se…” que travava o seu fluxo vira só mais uma etapa rodando sozinha. E o crédito é todo seu.

Testar o Code da Pluga agora →