Toda mensagem entregue
abre uma conversa.
Toda conversa vira receita.

Envie e receba por SMS, WhatsApp, e-mail e voz em uma API, um contrato e uma rede que já transporta 40% das mensagens comerciais de Angola.

Começar agora

Continuar com o Google

Arraste para girarSMS · LUANDA → LISBOA · 0,8s

4.000+ EMPRESAS ENVIAM PELA ZEXA — DE STARTUPS DE UM DEV A OPERAÇÕES DE ESCALA NACIONAL

Cliente 01
Cliente 02
Cliente 03
Cliente 04
Cliente 05
Cliente 06
Cliente 07
Cliente 08
Cliente 09
Cliente 10
Cliente 11
Cliente 12
Cliente 13
Cliente 14
Cliente 15

Integre num instante.
A mesma estrutura, em qualquer stack.

SDKs para TypeScript, Python e Go. REST, curl ou a CLI quando preferir dispensá-los. MCP para o agente ao seu lado.

import express from 'express';
import { Zexa } from '@zexa/sdk';

const zexa = new Zexa({ apiKey: process.env.ZEXA_API_KEY });
const app = express();
app.use(express.json());

app.post('/boas-vindas', async (req, res) => {
  await zexa.messages.send({
    channel: 'whatsapp',
    to: req.body.telefone,
    template: 'boas_vindas',
    fallback: ['sms'],
  });

  res.json({ enviado: true });
});

import { NextResponse } from 'next/server';
import { Zexa } from '@zexa/sdk';

const zexa = new Zexa({ apiKey: process.env.ZEXA_API_KEY });

export async function POST(request: Request) {
  const { telefone } = await request.json();

  await zexa.messages.send({
    channel: 'whatsapp',
    to: telefone,
    template: 'boas_vindas',
    fallback: ['sms'],
  });

  return NextResponse.json({ enviado: true });
}

import { Body, Controller, Post } from '@nestjs/common';
import { Zexa } from '@zexa/sdk';

@Controller('boas-vindas')
export class BoasVindasController {
  private zexa = new Zexa({ apiKey: process.env.ZEXA_API_KEY });

  @Post()
  async enviar(@Body('telefone') telefone: string) {
    await this.zexa.messages.send({
      channel: 'whatsapp',
      to: telefone,
      template: 'boas_vindas',
      fallback: ['sms'],
    });

    return { enviado: true };
  }
}

import Fastify from 'fastify';
import { Zexa } from '@zexa/sdk';

const zexa = new Zexa({ apiKey: process.env.ZEXA_API_KEY });
const app = Fastify();

app.post('/boas-vindas', async (request) => {
  await zexa.messages.send({
    channel: 'whatsapp',
    to: request.body.telefone,
    template: 'boas_vindas',
    fallback: ['sms'],
  });

  return { enviado: true };
});

await app.listen({ port: 3000 });

// server/api/boas-vindas.post.ts
import { Zexa } from '@zexa/sdk';

const zexa = new Zexa({ apiKey: process.env.ZEXA_API_KEY });

export default defineEventHandler(async (event) => {
  const { telefone } = await readBody(event);

  await zexa.messages.send({
    channel: 'whatsapp',
    to: telefone,
    template: 'boas_vindas',
    fallback: ['sms'],
  });

  return { enviado: true };
});

import { Hono } from 'hono';
import { Zexa } from '@zexa/sdk';

const zexa = new Zexa({ apiKey: process.env.ZEXA_API_KEY });
const app = new Hono();

app.post('/boas-vindas', async (c) => {
  const { telefone } = await c.req.json();

  await zexa.messages.send({
    channel: 'whatsapp',
    to: telefone,
    template: 'boas_vindas',
    fallback: ['sms'],
  });

  return c.json({ enviado: true });
});

export default app;

import { Zexa } from '@zexa/sdk';

const zexa = new Zexa({ apiKey: Bun.env.ZEXA_API_KEY });

Bun.serve({
  port: 3000,
  async fetch(request) {
    const { telefone } = await request.json();

    await zexa.messages.send({
      channel: 'whatsapp',
      to: telefone,
      template: 'boas_vindas',
      fallback: ['sms'],
    });

    return Response.json({ enviado: true });
  },
});

// src/pages/api/boas-vindas.ts
import type { APIRoute } from 'astro';
import { Zexa } from '@zexa/sdk';

const zexa = new Zexa({ apiKey: import.meta.env.ZEXA_API_KEY });

export const POST: APIRoute = async ({ request }) => {
  const { telefone } = await request.json();

  await zexa.messages.send({
    channel: 'whatsapp',
    to: telefone,
    template: 'boas_vindas',
    fallback: ['sms'],
  });

  return Response.json({ enviado: true });
};

import os

from fastapi import FastAPI
from zexa import Zexa

zexa = Zexa(api_key=os.environ['ZEXA_API_KEY'])
app = FastAPI()

@app.post('/boas-vindas')
async def boas_vindas(payload: dict):
    await zexa.messages.send(
        channel='whatsapp',
        to=payload['telefone'],
        template='boas_vindas',
        fallback=['sms'],
    )
    return {'enviado': True}

import json
import os

from django.http import JsonResponse
from django.views.decorators.http import require_POST
from zexa import Zexa

zexa = Zexa(api_key=os.environ['ZEXA_API_KEY'])

@require_POST
def boas_vindas(request):
    payload = json.loads(request.body)

    zexa.messages.send(
        channel='whatsapp',
        to=payload['telefone'],
        template='boas_vindas',
        fallback=['sms'],
    )
    return JsonResponse({'enviado': True})

import os

from flask import Flask, jsonify, request
from zexa import Zexa

zexa = Zexa(api_key=os.environ['ZEXA_API_KEY'])
app = Flask(__name__)

@app.post('/boas-vindas')
def boas_vindas():
    zexa.messages.send(
        channel='whatsapp',
        to=request.json['telefone'],
        template='boas_vindas',
        fallback=['sms'],
    )
    return jsonify(enviado=True)

import os

from celery import Celery
from zexa import Zexa

zexa = Zexa(api_key=os.environ['ZEXA_API_KEY'])
app = Celery('zexa', broker=os.environ['REDIS_URL'])

@app.task(bind=True, max_retries=3, default_retry_delay=30)
def enviar_boas_vindas(self, telefone):
    zexa.messages.send(
        channel='whatsapp',
        to=telefone,
        template='boas_vindas',
        fallback=['sms'],
    )

import os

from litestar import Litestar, post
from zexa import Zexa

zexa = Zexa(api_key=os.environ['ZEXA_API_KEY'])

@post('/boas-vindas')
async def boas_vindas(data: dict) -> dict:
    await zexa.messages.send(
        channel='whatsapp',
        to=data['telefone'],
        template='boas_vindas',
        fallback=['sms'],
    )
    return {'enviado': True}

app = Litestar([boas_vindas])

package main

import (
  "os"

  "github.com/gin-gonic/gin"
  "github.com/zexa/zexa-go"
)

func main() {
  client := zexa.New(os.Getenv("ZEXA_API_KEY"))
  r := gin.Default()

  r.POST("/boas-vindas", func(c *gin.Context) {
    var body struct{ Telefone string }
    c.BindJSON(&body)

    client.Messages.Send(c, &zexa.Message{
      Channel:  "whatsapp",
      To:       body.Telefone,
      Template: "boas_vindas",
      Fallback: []string{"sms"},
    })

    c.JSON(200, gin.H{"enviado": true})
  })

  r.Run(":3000")
}

package main

import (
  "net/http"
  "os"

  "github.com/labstack/echo/v4"
  "github.com/zexa/zexa-go"
)

func main() {
  client := zexa.New(os.Getenv("ZEXA_API_KEY"))
  e := echo.New()

  e.POST("/boas-vindas", func(c echo.Context) error {
    var body struct{ Telefone string }
    if err := c.Bind(&body); err != nil {
      return err
    }

    client.Messages.Send(c.Request().Context(), &zexa.Message{
      Channel:  "whatsapp",
      To:       body.Telefone,
      Template: "boas_vindas",
      Fallback: []string{"sms"},
    })

    return c.JSON(http.StatusOK, map[string]bool{"enviado": true})
  })

  e.Logger.Fatal(e.Start(":3000"))
}

package main

import (
  "os"

  "github.com/gofiber/fiber/v2"
  "github.com/zexa/zexa-go"
)

func main() {
  client := zexa.New(os.Getenv("ZEXA_API_KEY"))
  app := fiber.New()

  app.Post("/boas-vindas", func(c *fiber.Ctx) error {
    var body struct{ Telefone string }
    if err := c.BodyParser(&body); err != nil {
      return err
    }

    client.Messages.Send(c.Context(), &zexa.Message{
      Channel:  "whatsapp",
      To:       body.Telefone,
      Template: "boas_vindas",
      Fallback: []string{"sms"},
    })

    return c.JSON(fiber.Map{"enviado": true})
  })

  app.Listen(":3000")
}

package main

import (
  "encoding/json"
  "net/http"
  "os"

  "github.com/zexa/zexa-go"
)

func main() {
  client := zexa.New(os.Getenv("ZEXA_API_KEY"))

  http.HandleFunc("POST /boas-vindas", func(w http.ResponseWriter, r *http.Request) {
    var body struct{ Telefone string }
    json.NewDecoder(r.Body).Decode(&body)

    client.Messages.Send(r.Context(), &zexa.Message{
      Channel:  "whatsapp",
      To:       body.Telefone,
      Template: "boas_vindas",
      Fallback: []string{"sms"},
    })

    json.NewEncoder(w).Encode(map[string]bool{"enviado": true})
  })

  http.ListenAndServe(":3000", nil)
}

<?php

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
use Zexa\ZexaClient;

Route::post('/boas-vindas', function (Request $request) {
    $zexa = new ZexaClient(config('services.zexa.key'));

    $zexa->messages->send([
        'channel'  => 'whatsapp',
        'to'       => $request->input('telefone'),
        'template' => 'boas_vindas',
        'fallback' => ['sms'],
    ]);

    return response()->json(['enviado' => true]);
});

<?php

namespace App\Controller;

use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Attribute\Route;
use Zexa\ZexaClient;

class BoasVindasController
{
    #[Route('/boas-vindas', methods: ['POST'])]
    public function enviar(Request $request): JsonResponse
    {
        $zexa = new ZexaClient($_ENV['ZEXA_API_KEY']);

        $zexa->messages->send([
            'channel'  => 'whatsapp',
            'to'       => $request->toArray()['telefone'],
            'template' => 'boas_vindas',
            'fallback' => ['sms'],
        ]);

        return new JsonResponse(['enviado' => true]);
    }
}

<?php

use Slim\Factory\AppFactory;
use Zexa\ZexaClient;

$app = AppFactory::create();
$zexa = new ZexaClient(getenv('ZEXA_API_KEY'));

$app->post('/boas-vindas', function ($request, $response) use ($zexa) {
    $zexa->messages->send([
        'channel'  => 'whatsapp',
        'to'       => $request->getParsedBody()['telefone'],
        'template' => 'boas_vindas',
        'fallback' => ['sms'],
    ]);

    $response->getBody()->write('{"enviado":true}');

    return $response->withHeader('Content-Type', 'application/json');
});

$app->run();

import { Zexa } from '@zexa/sdk';

const zexa = new Zexa({ apiKey: process.env.ZEXA_API_KEY });

export const handler = async (event) => {
  const { telefone } = JSON.parse(event.body);

  await zexa.messages.send({
    channel: 'whatsapp',
    to: telefone,
    template: 'boas_vindas',
    fallback: ['sms'],
  });

  return {
    statusCode: 200,
    body: JSON.stringify({ enviado: true }),
  };
};

import { Zexa } from '@zexa/sdk';

export default {
  async fetch(request, env) {
    const zexa = new Zexa({ apiKey: env.ZEXA_API_KEY });
    const { telefone } = await request.json();

    await zexa.messages.send({
      channel: 'whatsapp',
      to: telefone,
      template: 'boas_vindas',
      fallback: ['sms'],
    });

    return Response.json({ enviado: true });
  },
};

import { Zexa } from '@zexa/sdk';

export const config = { runtime: 'edge' };

const zexa = new Zexa({ apiKey: process.env.ZEXA_API_KEY });

export default async function handler(request: Request) {
  const { telefone } = await request.json();

  await zexa.messages.send({
    channel: 'whatsapp',
    to: telefone,
    template: 'boas_vindas',
    fallback: ['sms'],
  });

  return Response.json({ enviado: true });
}

import express from 'express';
import { Zexa } from '@zexa/sdk';

const zexa = new Zexa({ apiKey: process.env.ZEXA_API_KEY });
const app = express();
app.use(express.json());

app.post('/boas-vindas', async (req, res) => {
  await zexa.messages.send({
    channel: 'whatsapp',
    to: req.body.telefone,
    template: 'boas_vindas',
    fallback: ['sms'],
  });

  res.json({ enviado: true });
});

// Cloud Run injects the port it wants the container to listen on.
app.listen(process.env.PORT || 8080);

curl -X POST https://api.zexa.io/v1/messages \
  -H "Authorization: Bearer $ZEXA_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "channel": "whatsapp",
    "to": "+244923000111",
    "template": "boas_vindas",
    "fallback": ["sms"]
  }'

http POST https://api.zexa.io/v1/messages \
  Authorization:"Bearer $ZEXA_API_KEY" \
  channel=whatsapp \
  to=+244923000111 \
  template=boas_vindas \
  fallback:='["sms"]'

$body = @{
  channel  = 'whatsapp'
  to       = '+244923000111'
  template = 'boas_vindas'
  fallback = @('sms')
} | ConvertTo-Json

$params = @{
  Method      = 'Post'
  Uri         = 'https://api.zexa.io/v1/messages'
  Headers     = @{ Authorization = "Bearer $env:ZEXA_API_KEY" }
  ContentType = 'application/json'
  Body        = $body
}

Invoke-RestMethod @params

$ zexa login
✓ autenticado como marina@sualoja.com

$ zexa send --channel whatsapp \
    --to +244923000111 \
    --template boas_vindas \
    --fallback sms

✓ msg_01J8Z…  enfileirada
✓ entregue em 0,8s

{
  "mcpServers": {
    "zexa": {
      "command": "npx",
      "args": ["-y", "@zexa/mcp"],
      "env": {
        "ZEXA_API_KEY": "sk_live_…"
      }
    }
  }
}

#!/usr/bin/env bash
set -euo pipefail

# Uma linha por telefone, uma mensagem por linha.
while read -r telefone; do
  zexa send \
    --channel whatsapp \
    --to "$telefone" \
    --template boas_vindas \
    --fallback sms
done < telefones.txt

01 / SMS · ROTA DIRETA EM 190 PAÍSES · FALLBACK EM SEGUNDOS · A2P 10DLC

Envie SMS. Operadoras Tier-1, mais de 190 países, com toda a conformidade tratada por nós.

Registro de remetente e cadastro de campanha resolvidos no onboarding. Roteamento inteligente por operadora: se uma rota degrada, o fallback assume antes do timeout. Um código de seis dígitos chega em menos de três segundos nas linhas que importam.

sms.ts200 · 0,8s

import { Zexa } from '@zexa/sdk';

const zexa = new Zexa({ apiKey: process.env.ZEXA_API_KEY });

await zexa.messages.send({
  channel: 'sms',
  to: '+5511998877665',
  text: 'Seu código Zexa é 418 220.',
  fallback: ['whatsapp'],
});

ZEXA · hoje 09:41

Seu código Zexa é 418 220. Não compartilhe com ninguém.

entregue0,84srota: Vivo direta

02 / WHATSAPP · API CLOUD OFICIAL · TEMPLATES APROVADOS · MÍDIA E BOTÕES

Envie WhatsApp. Templates, botões interativos e mídia, no canal que três bilhões de pessoas já utilizam.

Templates pré-aprovados, mensagens de sessão e respostas interativas com listas em cada mensagem. Um número, todas as conversas, com a mesma API que envia SMS e e-mail.

whatsapp.ts200 · 1,1s

await zexa.messages.send({
  channel: 'whatsapp',
  to: '+5511998877665',
  template: 'pedido_enviado',
  variables: { pedido: '#48812', prazo: 'quinta' },
  buttons: [
    { type: 'reply', label: 'Rastrear' },
    { type: 'reply', label: 'Mudar endereço' },
  ],
});

Oi, Marina! Seu pedido #48812 saiu para entrega e chega quinta.

Rastrear

lidaresposta em 41s

03 / E-MAIL · SPF, DKIM E DMARC TRATADOS · REACT EMAIL · IPS DEDICADOS

Envie e-mail. HTML e texto simples, React Email suportado, entregue na rede em que os ISPs já confiam.

IPs de envio direto, warm-up gerido e encaminhamento consolidado. Modelos renderizados em HTML e texto simples, com detalhamento de entrega por provedor e supressão automática.

email.tsx200 · 1,2s

import { Recibo } from './emails/recibo';

await zexa.emails.send({
  from: 'Sua Loja <oi@sualoja.com>',
  to: ['marina@exemplo.com'],
  subject: 'Seu recibo do pedido #48812',
  react: <Recibo pedido="48812" />,
});

Seu recibo do pedido #48812

oi@sualoja.com → marina@exemplo.com

Pedido: #48812
Itens: 3
Frete: R$ 0,00
Total: R$ 289,90

entregueinboxdkim: passspf: pass

99,3%

ENTREGA MÉDIA NACIONAL

02+

PAÍSES COM ROTA DIRETA

<80ms

LATÊNCIA MEDIANA DA API

4,2 B

MENSAGENS POR ANO

04 / INTEGRAÇÕES · OPERADORAS DE ANGOLA · CANAIS DE MENSAGEM · WEBHOOKS

Já integrado onde importa. Rota direta com as operadoras angolanas e os canais que o seu time já usa.

SMS entregue por interligação direta com Unitel, Africell e NOS — sem intermediários no caminho. Do outro lado, WhatsApp, Telegram e e-mail na mesma API, com o mesmo webhook de eventos.

integracoes.mapoperadoras: 3 · canais: 3 · ativos