Receba com PIX na sua stack,
do checkout ao saque.

X-Api-Key: sua_api_key
Content-Type: application/json

# só se a dashboard exigir assinatura (ver Segurança)
X-Signature: 3f9a…
X-Timestamp: 1727532000000
X-Nonce: 8b1e6c52-2f0e-4c0f-9d4a-1c2b3a4d5e6f

{ "success": false, "error": "Invalid API key" }

{
  "success": true,
  "data": { "transactionId": "b3f1…", "amount": 149.90 }
}

{
  "success": true,
  "data": [ … ],
  "meta": { "total": 137, "page": 1, "limit": 20, "pages": 7 }
}

{ "success": false, "error": "Saldo insuficiente" }

curl -X POST 'https://app.junglepagamentos.com/api/gateway/charges' \
  -H "X-Api-Key: $JUNGLE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "product":  { "name": "Plano Pro", "value": 149.90 },
    "customer": {
      "name": "João Silva",
      "email": "joao@exemplo.com",
      "doc": "11122233344",
      "docType": "cpf",
      "phone": "11912345678",
      "ip": "177.10.20.30"
    },
    "expiracaoSegundos": 3600,
    "callbackUrl": "https://seusite.com/webhooks/jungle",
    "metadata": { "pedido_id": "A-1001" }
  }'

export async function criarPix(pedido) {
  const res = await fetch('https://app.junglepagamentos.com/api/gateway/charges', {
    method: 'POST',
    headers: { 'X-Api-Key': process.env.JUNGLE_API_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      product: { name: pedido.titulo, value: pedido.total },   // reais
      customer: {
        name: pedido.cliente.nome,
        email: pedido.cliente.email,
        doc: pedido.cliente.cpf,
        ip: pedido.cliente.ip,                                  // IP do comprador
      },
      callbackUrl: 'https://seusite.com/webhooks/jungle',
      metadata: { pedido_id: pedido.id },
    }),
  })
  const body = await res.json()
  if (!body.success) throw new Error(`${res.status} ${body.error}`)
  return body.data // { transactionId, pixCode, expiresAt, amount, feeAmount, netAmount }
}

def criar_pix(pedido):
    r = requests.post(
        f"{API}/gateway/charges",
        headers={"X-Api-Key": os.environ["JUNGLE_API_KEY"]},
        json={
            "product": {"name": pedido.titulo, "value": float(pedido.total)},
            "customer": {
                "name": pedido.cliente.nome,
                "email": pedido.cliente.email,
                "doc": pedido.cliente.cpf,
                "ip": pedido.cliente.ip,
            },
            "callbackUrl": "https://seusite.com/webhooks/jungle",
            "metadata": {"pedido_id": pedido.id},
        },
        timeout=15,
    )
    body = r.json()
    if not body["success"]:
        raise RuntimeError(f'{r.status_code} {body["error"]}')
    return body["data"]

function criarPix(array $pedido): array {
  $ch = curl_init('https://app.junglepagamentos.com/api/gateway/charges');
  curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 15,
    CURLOPT_HTTPHEADER => ['X-Api-Key: ' . getenv('JUNGLE_API_KEY'), 'Content-Type: application/json'],
    CURLOPT_POSTFIELDS => json_encode([
      'product'  => ['name' => $pedido['titulo'], 'value' => (float) $pedido['total']],
      'customer' => ['name' => $pedido['nome'], 'email' => $pedido['email'], 'doc' => $pedido['cpf']],
      'callbackUrl' => 'https://seusite.com/webhooks/jungle',
      'metadata' => ['pedido_id' => $pedido['id']],
    ]),
  ]);
  $body = json_decode(curl_exec($ch), true);
  if (empty($body['success'])) throw new RuntimeException($body['error'] ?? 'erro');
  return $body['data'];
}

{
  "success": true,
  "data": {
    "transactionId": "b3f1c7e2-5a41-4b8e-9f0d-2c6a7e1d4b90",
    "pixCode": "00020126580014br.gov.bcb.pix0136…6304A1B2",
    "expiresAt": "2026-07-23T13:00:00.000Z",
    "amount": 149.90,
    "feeAmount": 5.25,
    "netAmount": 144.65
  }
}

{
  "metadata": {
    "pedido_id": "A-1001",
    "gclid": "Cj0KCQjw…",
    "fbp": "fb.1.1690000000000.1234567890",
    "fbclid": "IwAR2x…",
    "clickAt": "2026-07-23T11:58:12.000Z",
    "userAgent": "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X)…",
    "sourceUrl": "https://sualoja.com/checkout"
  }
}

{
  "metadata": {
    "pedido_id": "A-1001",
    "trackingParameters": { "gclid": "Cj0KCQjw…", "ttclid": "E.C.P.…" }
  }
}

// Rode na landing, ANTES do checkout, e guarde junto do carrinho.
const q = new URLSearchParams(location.search)
const cookie = (n) => document.cookie.match('(^|;)\\s*' + n + '=([^;]*)')?.[2]
const tracking = {
  gclid: q.get('gclid'), fbclid: q.get('fbclid'), ttclid: q.get('ttclid'),
  fbp: cookie('_fbp'), fbc: cookie('_fbc'), ttp: cookie('_ttp'),
  clickAt: new Date().toISOString(),
  userAgent: navigator.userAgent, sourceUrl: location.href,
}
// envie `tracking` ao SEU backend, que repassa em metadata na cobrança

curl 'https://app.junglepagamentos.com/api/gateway/transactions?page=1&limit=100' \
  -H "X-Api-Key: $JUNGLE_API_KEY"

// Varre todas as páginas (reconciliação noturna)
async function* transacoes() {
  for (let page = 1; ; page++) {
    const res = await fetch(`${API}/gateway/transactions?page=${page}&limit=100`, {
      headers: { 'X-Api-Key': process.env.JUNGLE_API_KEY },
    })
    const { success, data, meta, error } = await res.json()
    if (!success) throw new Error(error)
    yield* data
    if (page >= meta.pages) return
  }
}

def transacoes():
    page = 1
    while True:
        r = requests.get(f"{API}/gateway/transactions",
                         params={"page": page, "limit": 100},
                         headers={"X-Api-Key": os.environ["JUNGLE_API_KEY"]}, timeout=15)
        body = r.json()
        if not body["success"]:
            raise RuntimeError(body["error"])
        yield from body["data"]
        if page >= body["meta"]["pages"]:
            return
        page += 1

$ch = curl_init('https://app.junglepagamentos.com/api/gateway/transactions?page=1&limit=100');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => ['X-Api-Key: ' . getenv('JUNGLE_API_KEY')],
]);
$body = json_decode(curl_exec($ch), true);
foreach ($body['data'] as $tx) { /* $tx['status'] === 'PAID' */ }

{
  "success": true,
  "data": [
    {
      "id": "b3f1c7e2-…",
      "acquirerTxId": "abc123",
      "endToEndId": "E1234567890202607231240abcdef123",
      "status": "PAID",
      "productName": "Plano Pro",
      "productValue": 149.90,
      "amount": 149.90,
      "feeRate": 3.5,
      "feeAmount": 5.25,
      "netAmount": 144.65,
      "pixCode": "00020126580014br.gov.bcb.pix…",
      "pixExpiresAt": "2026-07-23T13:00:00.000Z",
      "paidAt": "2026-07-23T12:40:00.000Z",
      "customer": { "name": "João Silva", "email": "joao@exemplo.com", "doc": "11122233344", "phone": "11912345678" },
      "metadata": { "pedido_id": "A-1001" },
      "createdAt": "2026-07-23T12:00:00.000Z",
      "updatedAt": "2026-07-23T12:40:00.000Z"
    }
  ],
  "meta": { "total": 137, "page": 1, "limit": 100, "pages": 2 }
}

curl -X POST 'https://app.junglepagamentos.com/api/checkout/sessions' \
  -H "X-Api-Key: $JUNGLE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "checkoutId": "d78a3545-0920-41a9-a0e9-5d2a8d89946c",
    "products": [
      {
        "name": "Camiseta Oversized",
        "value": 89.90,
        "quantity": 2,
        "image": "https://cdn.sualoja.com/p/1.webp",
        "variant": "Preta · M"
      }
    ],
    "customer": { "email": "joao@exemplo.com" },
    "externalRef": "PEDIDO-A1001"
  }'

app.post('/finalizar', async (req, res) => {
  const carrinho = await carrinhos.get(req.session.cartId)
  const r = await fetch('https://app.junglepagamentos.com/api/checkout/sessions', {
    method: 'POST',
    headers: { 'X-Api-Key': process.env.JUNGLE_API_KEY, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      checkoutId: process.env.JUNGLE_CHECKOUT_ID,
      products: carrinho.itens.map(i => ({
        name: i.nome, value: i.preco, quantity: i.qtd, image: i.foto, variant: i.variacao,
      })),
      externalRef: `PEDIDO-${carrinho.id}`,
    }),
  })
  const { success, data, error } = await r.json()
  if (!success) return res.status(502).send(error)
  res.redirect(303, data.checkoutUrl)   // exatamente como veio
})

r = requests.post(
    f"{API}/checkout/sessions",
    headers={"X-Api-Key": os.environ["JUNGLE_API_KEY"]},
    json={
        "checkoutId": os.environ["JUNGLE_CHECKOUT_ID"],
        "products": [
            {"name": i.nome, "value": float(i.preco), "quantity": i.qtd, "image": i.foto}
            for i in carrinho.itens
        ],
        "externalRef": f"PEDIDO-{carrinho.id}",
    },
    timeout=15,
)
body = r.json()
return redirect(body["data"]["checkoutUrl"])

$payload = [
  'checkoutId' => getenv('JUNGLE_CHECKOUT_ID'),
  'products'   => array_map(fn($i) => [
    'name' => $i['nome'], 'value' => (float) $i['preco'], 'quantity' => $i['qtd'], 'image' => $i['foto'],
  ], $carrinho['itens']),
  'externalRef' => 'PEDIDO-' . $carrinho['id'],
];
$ch = curl_init('https://app.junglepagamentos.com/api/checkout/sessions');
curl_setopt_array($ch, [
  CURLOPT_POST => true, CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => ['X-Api-Key: ' . getenv('JUNGLE_API_KEY'), 'Content-Type: application/json'],
  CURLOPT_POSTFIELDS => json_encode($payload),
]);
$body = json_decode(curl_exec($ch), true);
header('Location: ' . $body['data']['checkoutUrl'], true, 303);

{
  "success": true,
  "data": {
    "sessionId": "5f0c2a9e-7b1d-4c3e-8a6f-9d2e1b0c4a7f",
    "amount": 179.80,
    "checkoutUrl": "https://pagar.sualoja.com/c/5f0c2a9e-7b1d-4c3e-8a6f-9d2e1b0c4a7f"
  }
}

curl 'https://app.junglepagamentos.com/api/checkout/sessions/5f0c2a9e-7b1d-4c3e-8a6f-9d2e1b0c4a7f'

const url = new URL(data.checkoutUrl)
url.searchParams.set('external_ref', 'PEDIDO-A1001')
location.href = url.toString()

{
  "event": "transaction.paid",
  "data": {
    "transactionId": "b3f1c7e2-…",
    "acquirerTxId": "abc123",
    "endToEndId": "E1234567890202607231240abcdef123",
    "status": "PAID",
    "amount": 149.90,
    "feeAmount": 5.25,
    "netAmount": 144.65,
    "productName": "Plano Pro",
    "customer": {
      "name": "João Silva",
      "email": "joao@exemplo.com",
      "doc": "11122233344",
      "phone": "11912345678"
    },
    "metadata": { "pedido_id": "A-1001" },
    "paidAt": "2026-07-23T12:40:00.000Z",
    "createdAt": "2026-07-23T12:00:00.000Z"
  }
}

import express from 'express'
import { createHmac, timingSafeEqual } from 'node:crypto'

const app = express()
const SECRET = process.env.JUNGLE_WEBHOOK_SECRET

app.post('/webhooks/jungle', express.raw({ type: 'application/json' }), async (req, res) => {
  const expected = createHmac('sha256', SECRET).update(req.body).digest('hex')
  const got = String(req.header('x-signature') ?? '')
  const ok = got.length === expected.length &&
    timingSafeEqual(Buffer.from(got), Buffer.from(expected))
  if (!ok) return res.status(401).end()

  const evt = JSON.parse(req.body.toString('utf8'))
  res.status(200).end()

  if (await jaProcessado(evt.data.transactionId, evt.event)) return
  if (evt.event === 'transaction.paid' && evt.data.status === 'PAID') {
    await liberarPedido(evt.data.metadata.pedido_id)
  }
})

// Cloudflare Workers, Next.js edge, Deno, Bun
export async function POST(req) {
  const raw = await req.text()
  const sig = req.headers.get('x-signature') ?? ''
  const key = await crypto.subtle.importKey(
    'raw', new TextEncoder().encode(process.env.JUNGLE_WEBHOOK_SECRET),
    { name: 'HMAC', hash: 'SHA-256' }, false, ['sign'])
  const mac = new Uint8Array(await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(raw)))
  const hex = [...mac].map(b => b.toString(16).padStart(2, '0')).join('')
  let diff = hex.length ^ sig.length
  for (let i = 0; i < hex.length; i++) diff |= hex.charCodeAt(i) ^ sig.charCodeAt(i)
  if (diff !== 0) return new Response(null, { status: 401 })

  const evt = JSON.parse(raw)
  // enfileire e processe de forma idempotente
  return new Response(null, { status: 200 })
}

import hmac, hashlib, os
from flask import Flask, request, abort

app = Flask(__name__)
SECRET = os.environ["JUNGLE_WEBHOOK_SECRET"].encode()

@app.post("/webhooks/jungle")
def jungle_webhook():
    raw = request.get_data()                      # corpo BRUTO
    expected = hmac.new(SECRET, raw, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(expected, request.headers.get("X-Signature", "")):
        abort(401)
    evt = request.get_json()
    if evt["event"] == "transaction.paid" and evt["data"]["status"] == "PAID":
        fila.enqueue(liberar_pedido, evt["data"]["metadata"]["pedido_id"])
    return "", 200

<?php
$raw = file_get_contents('php://input');
$expected = hash_hmac('sha256', $raw, getenv('JUNGLE_WEBHOOK_SECRET'));
$got = $_SERVER['HTTP_X_SIGNATURE'] ?? '';

if (!hash_equals($expected, $got)) {
  http_response_code(401);
  exit;
}

$evt = json_decode($raw, true);
http_response_code(200);

if ($evt['event'] === 'transaction.paid' && $evt['data']['status'] === 'PAID') {
  liberarPedido($evt['data']['metadata']['pedido_id']);
}

func jungleWebhook(w http.ResponseWriter, r *http.Request) {
	raw, _ := io.ReadAll(r.Body)
	mac := hmac.New(sha256.New, []byte(os.Getenv("JUNGLE_WEBHOOK_SECRET")))
	mac.Write(raw)
	expected := hex.EncodeToString(mac.Sum(nil))
	if !hmac.Equal([]byte(expected), []byte(r.Header.Get("X-Signature"))) {
		w.WriteHeader(http.StatusUnauthorized)
		return
	}
	var evt struct {
		Event string `json:"event"`
		Data  struct {
			TransactionID string         `json:"transactionId"`
			Status        string         `json:"status"`
			Metadata      map[string]any `json:"metadata"`
		} `json:"data"`
	}
	json.Unmarshal(raw, &evt)
	w.WriteHeader(http.StatusOK)
	// idempotência por evt.Data.TransactionID + evt.Event
}

import { createHmac, randomUUID } from 'node:crypto'

const API = 'https://app.junglepagamentos.com/api'

export async function sacar({ amount, pixKey, pixKeyType, idempotencyKey }) {
  const path = '/api/gateway/withdrawals'
  const raw = JSON.stringify({ amount, pixKey, pixKeyType })
  const ts = Date.now().toString()
  const nonce = randomUUID()
  const canonical = `POST\n${path}\n${raw}\n${ts}\n${nonce}\n${idempotencyKey}`
  const signature = createHmac('sha256', process.env.JUNGLE_WEBHOOK_SECRET)
    .update(canonical).digest('hex')

  const res = await fetch(`${API}/gateway/withdrawals`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-Api-Key': process.env.JUNGLE_API_KEY,
      'X-Signature': signature,
      'X-Timestamp': ts,
      'X-Nonce': nonce,
      'Idempotency-Key': idempotencyKey,   // a MESMA em todo retry
    },
    body: raw,                              // exatamente a string assinada
  })
  const body = await res.json()
  if (!body.success) throw new Error(`${res.status} ${body.error}`)
  return body.data  // { withdrawalId, status: 'PENDING', amount, feeAmount, netAmount, totalAmount }
}

import hmac, hashlib, json, os, time, uuid, requests

def sacar(amount, idempotency_key, pix_key=None, pix_key_type=None):
    path = "/api/gateway/withdrawals"
    payload = {"amount": amount}
    if pix_key:
        payload |= {"pixKey": pix_key, "pixKeyType": pix_key_type}
    raw = json.dumps(payload, separators=(",", ":"))
    ts = str(int(time.time() * 1000))
    nonce = str(uuid.uuid4())
    canonical = f"POST\n{path}\n{raw}\n{ts}\n{nonce}\n{idempotency_key}"
    sig = hmac.new(os.environ["JUNGLE_WEBHOOK_SECRET"].encode(),
                   canonical.encode(), hashlib.sha256).hexdigest()
    r = requests.post(
        "https://app.junglepagamentos.com" + path,
        data=raw,                                  # a MESMA string assinada
        headers={
            "Content-Type": "application/json",
            "X-Api-Key": os.environ["JUNGLE_API_KEY"],
            "X-Signature": sig, "X-Timestamp": ts, "X-Nonce": nonce,
            "Idempotency-Key": idempotency_key,
        },
        timeout=20,
    )
    body = r.json()
    if not body["success"]:
        raise RuntimeError(f'{r.status_code} {body["error"]}')
    return body["data"]

function sacar(float $amount, string $idempotencyKey): array {
  $path  = '/api/gateway/withdrawals';
  $raw   = json_encode(['amount' => $amount]);
  $ts    = (string) round(microtime(true) * 1000);
  $nonce = bin2hex(random_bytes(16));
  $canonical = "POST\n{$path}\n{$raw}\n{$ts}\n{$nonce}\n{$idempotencyKey}";
  $sig = hash_hmac('sha256', $canonical, getenv('JUNGLE_WEBHOOK_SECRET'));

  $ch = curl_init('https://app.junglepagamentos.com' . $path);
  curl_setopt_array($ch, [
    CURLOPT_POST => true, CURLOPT_RETURNTRANSFER => true, CURLOPT_POSTFIELDS => $raw,
    CURLOPT_HTTPHEADER => [
      'Content-Type: application/json',
      'X-Api-Key: ' . getenv('JUNGLE_API_KEY'),
      "X-Signature: {$sig}", "X-Timestamp: {$ts}", "X-Nonce: {$nonce}",
      "Idempotency-Key: {$idempotencyKey}",
    ],
  ]);
  $body = json_decode(curl_exec($ch), true);
  if (empty($body['success'])) throw new RuntimeException($body['error'] ?? 'erro');
  return $body['data'];
}

{
  "success": true,
  "data": {
    "withdrawalId": "c9a24f1e-…",
    "status": "PENDING",
    "amount": 150.00,
    "feeAmount": 10.00,
    "netAmount": 150.00,
    "totalAmount": 160.00
  }
}

curl 'https://app.junglepagamentos.com/api/gateway/withdrawals/c9a24f1e-…' \
  -H "X-Api-Key: $JUNGLE_API_KEY"

{
  "success": true,
  "data": {
    "withdrawalId": "c9a24f1e-…",
    "status": "ENVIADO",
    "amount": 150.00,
    "feeAmount": 10.00,
    "netAmount": 150.00,
    "totalAmount": 160.00,
    "pixKeyType": "email",
    "createdAt": "2026-07-23T12:00:00.000Z"
  }
}

{
  "event": "withdrawal.paid",
  "data": {
    "withdrawalId": "c9a24f1e-…",
    "amount": 100.00,
    "feeAmount": 0,
    "netAmount": 100.00,
    "totalAmount": 100.00,
    "status": "ENVIADO",
    "pixKeyType": "email",
    "pixKeyMasked": "lo***@exemplo.com",
    "failureReason": null,
    "createdAt": "2026-07-23T12:00:00.000Z",
    "updatedAt": "2026-07-23T12:05:00.000Z"
  }
}

import { createHmac, randomUUID } from 'node:crypto'

const API = 'https://app.junglepagamentos.com/api'
const KEY = process.env.JUNGLE_API_KEY

export async function jungle(method, route, body) {
  const path = new URL(API + route).pathname          // /api/gateway/…
  const raw = body === undefined ? '' : JSON.stringify(body)
  const ts = Date.now().toString()
  const nonce = randomUUID()
  const sig = createHmac('sha256', KEY)
    .update(`${method}\n${path}\n${raw}\n${ts}\n${nonce}`).digest('hex')

  const res = await fetch(API + route, {
    method,
    headers: {
      'Content-Type': 'application/json', 'X-Api-Key': KEY,
      'X-Signature': sig, 'X-Timestamp': ts, 'X-Nonce': nonce,
    },
    body: method === 'GET' ? undefined : raw,
  })
  const json = await res.json()
  if (!json.success) throw new Error(`${res.status} ${json.error}`)
  return json
}

// jungle('POST', '/gateway/charges', { product: …, customer: … })
// jungle('GET', '/gateway/transactions?page=1')  → assina só o pathname

import hmac, hashlib, json, os, time, uuid, requests
from urllib.parse import urlparse

API = "https://app.junglepagamentos.com/api"
KEY = os.environ["JUNGLE_API_KEY"]

def jungle(method, route, body=None):
    path = urlparse(API + route).path
    raw = "" if body is None else json.dumps(body, separators=(",", ":"))
    ts, nonce = str(int(time.time() * 1000)), str(uuid.uuid4())
    sig = hmac.new(KEY.encode(), f"{method}\n{path}\n{raw}\n{ts}\n{nonce}".encode(),
                   hashlib.sha256).hexdigest()
    r = requests.request(method, API + route, data=raw or None, timeout=15, headers={
        "Content-Type": "application/json", "X-Api-Key": KEY,
        "X-Signature": sig, "X-Timestamp": ts, "X-Nonce": nonce,
    })
    out = r.json()
    if not out["success"]:
        raise RuntimeError(f'{r.status_code} {out["error"]}')
    return out

claude mcp add --transport http jungle \
  https://app.junglepagamentos.com/api/mcp \
  --header "Authorization: Bearer jmcp_SEU_TOKEN"

# confira
claude mcp list

// ~/.cursor/mcp.json
{
  "mcpServers": {
    "jungle": {
      "type": "http",
      "url": "https://app.junglepagamentos.com/api/mcp",
      "headers": { "Authorization": "Bearer jmcp_SEU_TOKEN" }
    }
  }
}

// .vscode/mcp.json
{
  "servers": {
    "jungle": {
      "type": "http",
      "url": "https://app.junglepagamentos.com/api/mcp",
      "headers": { "Authorization": "Bearer jmcp_SEU_TOKEN" }
    }
  }
}

// claude_desktop_config.json — ponte mcp-remote (requer Node 18+)
{
  "mcpServers": {
    "jungle": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://app.junglepagamentos.com/api/mcp",
        "--header", "Authorization:${JUNGLE_MCP_AUTH}"
      ],
      "env": { "JUNGLE_MCP_AUTH": "Bearer jmcp_SEU_TOKEN" }
    }
  }
}

curl -s https://app.junglepagamentos.com/api/mcp \
  -H 'Authorization: Bearer jmcp_SEU_TOKEN' \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
       "params":{"name":"data_freshness","arguments":{}}}'

// → POST /api/mcp
{ "jsonrpc": "2.0", "id": 1, "method": "initialize",
  "params": { "protocolVersion": "2025-06-18", "capabilities": {},
              "clientInfo": { "name": "meu-cliente", "version": "1.0" } } }

// ←
{ "jsonrpc": "2.0", "id": 1, "result": {
    "protocolVersion": "2025-06-18",
    "capabilities": { "tools": { "listChanged": false } },
    "serverInfo": { "name": "jungle-checkout-analytics", "version": "1.0.0" },
    "instructions": "…" } }

// → POST /api/mcp
{ "jsonrpc": "2.0", "id": 7, "method": "tools/call",
  "params": { "name": "get_checkout_funnel",
              "arguments": { "from": "2026-09-01", "to": "2026-09-14", "group_by": "device" } } }

// ← resultado vem em texto (JSON) e estruturado
{ "jsonrpc": "2.0", "id": 7, "result": {
    "content": [ { "type": "text", "text": "{\"period\":{…},\"rows\":[…]}" } ],
    "structuredContent": { "period": { … }, "rows": [ … ] },
    "isError": false } }

// Falha de auth → HTTP 401 + WWW-Authenticate: Bearer realm="jungle-mcp"
{ "jsonrpc": "2.0", "id": null,
  "error": { "code": -32001, "message": "Unauthorized: …" } }

// Rate limit → HTTP 429 + Retry-After
{ "jsonrpc": "2.0", "id": 3, "error": { "code": -32002, "message": "…" } }

// Erro da FERRAMENTA não é erro JSON-RPC: volta como resultado
{ "jsonrpc": "2.0", "id": 9, "result": {
    "content": [ { "type": "text", "text": "Período maior que 90 dias." } ],
    "isError": true } }

// -32700 JSON inválido · -32600 request inválido · -32601 método
// -32602 ferramenta inexistente ou arguments inválido