MoMenu Payment API

curl -X POST https://api.momenu.online/api/payment/mcx \
  -H "Content-Type: application/json" \
  -H "x-api-key: SUA_API_KEY" \
  -d '{
    "paymentInfo": {
      "amount": 1000,
      "phoneNumber": "244923456789"
    }
  }'

Content-Type: application/json
x-api-key: sua_chave_api_aqui
x-env-qa: true     // opcional - ambiente QA (qualquer origem)
x-dev-mode: true   // opcional - bypass domínio (apenas localhost)

Content-Type: application/json
x-api-key: a1b2c3d4-e5f6-7890-abcd-ef1234567890  // key gerada no painel

{
  "success": false,
  "error": "paymentInfo.amount (2500) deve ser igual ao total dos produtos (3000.00)",
  "code": "AMOUNT_MISMATCH"
}

{
  "event": "payment.confirmed",
  "merchantTransactionId": "abc123...",
  "ekwanzaTransactionId": "EKZ456...",
  "operationStatus": "1",
  "operationData": { ... }
}

{
  "event": "invoice.created",
  "merchantTransactionId": "abc123...",
  "ekwanzaTransactionId": "EKZ456...",
  "operationStatus": "1",
  "operationData": { ... },
  "invoiceUrl": "https://invoice-momenu.toquemedia.net/invoices/..."
}

const express = require("express");
const app = express();

app.use(express.json());

app.post("/webhook/meu-webhook", (req, res) => {
  const { event, merchantTransactionId, operationStatus, invoiceUrl } = req.body;

  switch (event) {
    case "payment.confirmed":
      console.log("Pagamento confirmado:", merchantTransactionId);
      // Atualizar estado da encomenda no seu sistema
      break;

    case "invoice.created":
      console.log("Fatura disponivel:", invoiceUrl);
      // Guardar URL da fatura, enviar ao cliente
      break;

    default:
      // Eventos sem campo "event" (cancelado, falhado, erro)
      if (["3", "4", "5"].includes(operationStatus)) {
        console.log("Pagamento falhou:", operationStatus);
      }
  }

  res.status(200).json({ received: true });
});

app.listen(3000);

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/webhook/meu-webhook", methods=["POST"])
def momenu_webhook():
    data = request.json
    event = data.get("event")
    transaction_id = data.get("merchantTransactionId")
    status = data.get("operationStatus")

    if event == "payment.confirmed":
        print(f"Pagamento confirmado: {transaction_id}")
        # Atualizar estado da encomenda

    elif event == "invoice.created":
        invoice_url = data.get("invoiceUrl")
        print(f"Fatura disponivel: {invoice_url}")
        # Guardar URL da fatura

    elif status in ["3", "4", "5"]:
        print(f"Pagamento falhou: {status}")

    return jsonify({"received": True}), 200

// Pagamento simples via Multicaixa Express
async function processarPagamentoMCX(amount, phoneNumber) {
  const response = await fetch("https://api.momenu.online/api/payment/mcx", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": "SUA_API_KEY"
    },
    body: JSON.stringify({
      paymentInfo: { amount, phoneNumber }
    })
  });

  const data = await response.json();

  if (data.success) {
    console.log("Pago! Fatura:", data.invoiceUrl);
    return data;
  } else {
    throw new Error(data.error);
  }
}

// 1. Iniciar pagamento E-kwanza
async function iniciarEkwanza(amount, phoneNumber) {
  const response = await fetch("https://api.momenu.online/api/payment/ekwanza", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": "SUA_API_KEY"
    },
    body: JSON.stringify({
      paymentInfo: { amount, phoneNumber }
    })
  });

  const data = await response.json();

  if (data.success) {
    // Exibir QR code ao utilizador
    exibirQRCode(data.qrCode);
    // Verificar status com polling
    return data;
  }

  throw new Error(data.error);
}

// 2. Verificar status do pagamento (polling)
async function verificarStatusEkwanza(code, merchantTransactionId) {
  const url = `https://api.momenu.online/api/payment/ekwanza/status/${code}?merchantTransactionId=${merchantTransactionId}`;
  const response = await fetch(
    url,
    { headers: { "x-api-key": "SUA_API_KEY" } }
  );

  const data = await response.json();

  if (data.status === "paid") {
    console.log("Pago! Fatura:", data.invoiceUrl);
  }

  return data;
}

const axios = require("axios");

const API_URL = "https://api.momenu.online";
const API_KEY = process.env.MOM_FACTURA_API_KEY;

const client = axios.create({
  baseURL: API_URL,
  headers: {
    "Content-Type": "application/json",
    "x-api-key": API_KEY
  }
});

// Pagamento MCX
async function pagarMCX(amount, phoneNumber, products) {
  try {
    const { data } = await client.post("/api/payment/mcx", {
      paymentInfo: { amount, phoneNumber },
      products
    });
    return data;
  } catch (error) {
    throw new Error(error.response?.data?.error || "Erro de pagamento");
  }
}

// Gerar referência bancária
async function gerarReferência(amount, products, customer) {
  try {
    const { data } = await client.post("/api/payment/reference", {
      paymentInfo: { amount },
      products,
      customer
    });
    return data;
  } catch (error) {
    throw new Error(error.response?.data?.error || "Erro ao gerar referência");
  }
}

// Verificar status de referência
async function verificarReferência(operationId, merchantTransactionId) {
  try {
    const { data } = await client.get(
      `/api/payment/reference/status/${operationId}?merchantTransactionId=${merchantTransactionId}`
    );
    return data;
  } catch (error) {
    throw new Error(error.response?.data?.error || "Erro ao verificar status");
  }
}

import requests
import time
import os

API_URL = "https://api.momenu.online"
API_KEY = os.environ["MOM_FACTURA_API_KEY"]

headers = {
    "Content-Type": "application/json",
    "x-api-key": API_KEY
}

# Pagamento MCX
def pagar_mcx(amount, phone_number, products=None):
    payload = {
        "paymentInfo": {
            "amount": amount,
            "phoneNumber": phone_number
        }
    }
    if products:
        payload["products"] = products

    response = requests.post(
        f"{API_URL}/api/payment/mcx",
        json=payload,
        headers=headers
    )
    data = response.json()

    if not data.get("success"):
        raise Exception(data.get("error", "Erro desconhecido"))

    return data

# Pagamento E-kwanza (confirmação via status polling)
def pagar_ekwanza(amount, phone_number):
    response = requests.post(
        f"{API_URL}/api/payment/ekwanza",
        json={
            "paymentInfo": {
                "amount": amount,
                "phoneNumber": phone_number
            }
        },
        headers=headers
    )
    data = response.json()

    if not data.get("success"):
        raise Exception(data.get("error"))

    # Exibir QR code: data["qrCode"]
    # Verificar status: data["code"] (path) + data["merchantTransactionId"] (query)
    return data

# Verificar status E-kwanza (polling)
def verificar_status_ekwanza(code, merchant_transaction_id):
    response = requests.get(
        f"{API_URL}/api/payment/ekwanza/status/{code}",
        params={"merchantTransactionId": merchant_transaction_id},
        headers=headers
    )
    data = response.json()

    if data.get("status") == "paid":
        print(f"Pago! Fatura: {data['invoiceUrl']}")

    return data

curl -X POST https://api.momenu.online/api/payment/mcx \
  -H "Content-Type: application/json" \
  -H "x-api-key: sua_api_key" \
  -H "x-env-qa: true" \
  -d '{
    "paymentInfo": {
      "amount": 5000,
      "phoneNumber": "244923456789"
    },
    "simulateResult": "insufficient_balance"
  }'

{
  "success": false,
  "error": "Descrição do erro",
  "code": "ERROR_CODE"
}

{
  "success": false,
  "error": "Demasiadas requisições. Tente novamente em breve.",
  "code": "RATE_LIMIT_EXCEEDED"
}

# Instalar todos os skills
npx skills add ithustle/momenu-skills --all

# Ou instalar skills especificos
npx skills add ithustle/momenu-skills --skill mom-factura-payments -y
npx skills add ithustle/momenu-skills --skill mom-factura-webhooks -y
npx skills add ithustle/momenu-skills --skill mom-factura-testing -y

# Claude Code: .claude/skills/
git clone https://github.com/ithustle/momenu-skills.git
cp -r momenu-skills/skills/mom-factura-payments .claude/skills/

# OpenAI Codex CLI: .codex/skills/
git clone https://github.com/ithustle/momenu-skills.git
cp -r momenu-skills/skills/mom-factura-payments .codex/skills/

# Cursor / Copilot / Outros: consulte a documentação do agente

npx skills add ithustle/momenu-skills --skill mom-factura-payments -y

mom-factura-payments/
  SKILL.md                        # Instruções principais
  references/
    STATUS-POLLING.md             # Referência de webhook e status (fallback)

npx skills add ithustle/momenu-skills --skill mom-factura-webhooks -y

npx skills add ithustle/momenu-skills --skill mom-factura-testing -y