Griito API

Documentación completa para integrar llamadas automatizadas en tu aplicación.

Base URL

https://api.griito.com

Formato de envío

Todas las solicitudes usan application/x-www-form-urlencoded, excepto el endpoint /audios que requiere multipart/form-data.

Todas las respuestas son JSON.

Autenticación

POST /register

Crea una nueva cuenta de usuario.

curl -X POST https://api.griito.com/register \
  -d "client_id=YOUR_CLIENT_ID" \
  -d "client_secret=YOUR_CLIENT_SECRET" \
  -d "name=Juan Pérez" \
  -d "email=juan@ejemplo.com" \
  -d "password=mi_password_seguro"

Response

{
  "message": "user created",
  "user_id": 42
}

POST /oauth/token

Obtiene un token de acceso OAuth 2.0.

curl -X POST https://api.griito.com/oauth/token \
  -d "grant_type=password" \
  -d "client_id=YOUR_CLIENT_ID" \
  -d "client_secret=YOUR_CLIENT_SECRET" \
  -d "username=juan@ejemplo.com" \
  -d "password=mi_password_seguro" \
  -d "scope=*"

Response

{
  "token_type": "Bearer",
  "expires_in": 31536000,
  "access_token": "eyJ0eXAiOiJKV1QiLCJhbGci...",
  "refresh_token": "def50200ae5b0..."
}

Usuario

GET /user

Obtiene los datos del usuario autenticado.

curl https://api.griito.com/user \
  -H "Authorization: Bearer YOUR_TOKEN"

Response

{
  "id": 42,
  "name": "Juan Pérez",
  "email": "juan@ejemplo.com",
  "callerid": "+56912345678",
  "maxrcp": 1000,
  "plan_id": 2,
  "country": "CL",
  "created_at": "2024-01-15T10:30:00.000000Z"
}

PATCH /user

Actualiza datos del usuario. Todos los parámetros son opcionales.

curl -X PATCH https://api.griito.com/user \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d "name=Juan Actualizado"

GET /credits

Consulta los créditos disponibles del usuario.

curl https://api.griito.com/credits \
  -H "Authorization: Bearer YOUR_TOKEN"

Response

{
  "credits": 150.50
}

Audios

GET /audios

Lista todos los audios del usuario.

curl https://api.griito.com/audios \
  -H "Authorization: Bearer YOUR_TOKEN"

Response

{
  "data": [
    {
      "id": 1,
      "id_api": "abc123",
      "nombre_grabacion": "saludo_cliente",
      "fecha_creacion": "2024-06-01 14:30:00",
      "activo": 1,
      "descripcion": "Audio de bienvenida",
      "status": "ready"
    }
  ]
}

POST /audios

Sube un nuevo audio. Usa multipart/form-data. El servidor normaliza el archivo a WAV 8kHz mono automáticamente.

curl -X POST https://api.griito.com/audios \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -F "audio=@/ruta/a/mi_audio.mp3" \
  -F "name=saludo_cliente" \
  -F "description=Audio de bienvenida para clientes"

Response

{
  "success": true,
  "text": "Audio guardado",
  "data": {
    "id": 5,
    "id_api": "xyz789",
    "nombre_grabacion": "saludo_cliente",
    "descripcion": "Audio de bienvenida para clientes"
  }
}

GET /audios/{id}

Obtiene el detalle de un audio específico, incluyendo la URL del archivo.

curl https://api.griito.com/audios/5 \
  -H "Authorization: Bearer YOUR_TOKEN"

DELETE /audios/{id}

Elimina un audio (soft delete).

curl -X DELETE https://api.griito.com/audios/5 \
  -H "Authorization: Bearer YOUR_TOKEN"

Llamadas

El recurso principal de la API. Permite crear, consultar, modificar y cancelar llamadas automatizadas.

Tipos de llamada

Estados de llamada

POST /calls

Crea una o más llamadas.

Parámetros comunes

Parámetros para tipo 0 y 1 (audio)

Parámetros para tipo 2 y 3 (TTS)

Parámetros opcionales

Ejemplo — Llamada tipo 0 (audio unidireccional):

curl -X POST https://api.griito.com/calls \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d "type=0" \
  -d "recipients=+56912345678" \
  -d "audio=5" \
  -d "abrid=pedido_1001"

Response

{
  "success": true,
  "text": "Mensaje(s) Ingresado",
  "data": [101],
  "batch_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
}

Ejemplo — Llamada tipo 2 (TTS unidireccional):

curl -X POST https://api.griito.com/calls \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d "type=2" \
  -d "recipients=+56912345678" \
  -d "tts=Hola Juan, tu pedido número 1001 está listo para retiro."

GET /calls

Lista las llamadas del usuario con paginación.

curl https://api.griito.com/calls \
  -H "Authorization: Bearer YOUR_TOKEN"

GET /calls/{id}

Detalle de una llamada específica. Si es tipo 1 o 3, incluye response_audio con la URL de la grabación de respuesta.

curl https://api.griito.com/calls/101 \
  -H "Authorization: Bearer YOUR_TOKEN"

PATCH /calls/{id}

Modifica una llamada pendiente (ej: reprogramar).

curl -X PATCH https://api.griito.com/calls/101 \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d "calldate=2025-03-15T14:00:00Z"

DELETE /calls/{id}

Cancela una llamada específica.

curl -X DELETE https://api.griito.com/calls/101 \
  -H "Authorization: Bearer YOUR_TOKEN"

DELETE /calls

Cancela múltiples llamadas.

curl -X DELETE https://api.griito.com/calls \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d "id[]=101" \
  -d "id[]=102" \
  -d "id[]=103"

DELETE /calls/batch/{batch_id}

Cancela todas las llamadas de un batch.

curl -X DELETE https://api.griito.com/calls/batch/a1b2c3d4-e5f6-7890-abcd-ef1234567890 \
  -H "Authorization: Bearer YOUR_TOKEN"

DELETE /calls/pending/batch/{batch_id}

Cancela solo las llamadas pendientes (estado 0) de un batch.

curl -X DELETE https://api.griito.com/calls/pending/batch/a1b2c3d4-e5f6-7890-abcd-ef1234567890 \
  -H "Authorization: Bearer YOUR_TOKEN"

Envío masivo (batch)

Para enviar llamadas a múltiples destinatarios en una sola solicitud, los parámetros recipients, audio/tts, abrid y calltime pueden ser arrays del mismo largo.

Ejemplo — Envío masivo TTS personalizado a 3 destinatarios:

curl -X POST https://api.griito.com/calls \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d "type=2" \
  -d "recipients[]=+56911111111" \
  -d "recipients[]=+56922222222" \
  -d "recipients[]=+56933333333" \
  -d "tts[]=Hola María, tu cita es mañana a las 10." \
  -d "tts[]=Hola Pedro, tu cita es mañana a las 11." \
  -d "tts[]=Hola Ana, tu cita es mañana a las 12." \
  -d "abrid[]=cita_maria" \
  -d "abrid[]=cita_pedro" \
  -d "abrid[]=cita_ana" \
  -d "batch_name=recordatorio_citas"

Response

{
  "success": true,
  "text": "Mensaje(s) Ingresado",
  "data": [201, 202, 203],
  "batch_id": "f1e2d3c4-b5a6-7890-fedc-ba0987654321"
}

Programación de llamadas

Parámetro calltime

Permite programar una llamada para una fecha y hora futura. Usa formato ISO 8601.

# Llamada programada para el 15 de marzo 2025 a las 14:00 UTC
-d "calltime=2025-03-15T14:00:00Z"

# Con zona horaria específica
-d "calltime=2025-03-15T11:00:00" \
-d "timezone=America/Santiago"

Parámetro timezone

Define la zona horaria para interpretar calltime. Por defecto es UTC. Acepta cualquier zona IANA válida (ej: America/Santiago, America/Mexico_City, Europe/Madrid).

Restricciones horarias

Las llamadas tienen restricciones de horario para proteger a los destinatarios. Si intentas crear una llamada fuera del horario permitido:

• adjust_schedule=true — La llamada se reprograma automáticamente al próximo horario permitido
• force_schedule=true — Fuerza la programación sin ajustar (puede fallar según el plan)
• Sin estos parámetros — Recibirás error código 52

Códigos de error

Cuando una solicitud falla, la respuesta incluye un código numérico y un mensaje descriptivo.

{
  "success": false,
  "error_code": 22,
  "text": "Sin créditos disponibles"
}

Ejemplos completos

Flujos completos de integración en distintos lenguajes.

Flujo completo: Auth → Subir audio → Llamada tipo 0

# 1. Obtener token
TOKEN=$(curl -s -X POST https://api.griito.com/oauth/token \
  -d "grant_type=password" \
  -d "client_id=YOUR_CLIENT_ID" \
  -d "client_secret=YOUR_CLIENT_SECRET" \
  -d "username=juan@ejemplo.com" \
  -d "password=mi_password" \
  -d "scope=*" | jq -r '.access_token')

echo "Token: $TOKEN"

# 2. Subir audio
AUDIO_ID=$(curl -s -X POST https://api.griito.com/audios \
  -H "Authorization: Bearer $TOKEN" \
  -F "audio=@/ruta/a/mi_audio.mp3" \
  -F "name=aviso_despacho" \
  -F "description=Aviso de despacho de pedido" | jq -r '.data.id')

echo "Audio ID: $AUDIO_ID"

# 3. Crear llamada tipo 0
curl -X POST https://api.griito.com/calls \
  -H "Authorization: Bearer $TOKEN" \
  -d "type=0" \
  -d "recipients=+56912345678" \
  -d "audio=$AUDIO_ID" \
  -d "abrid=pedido_5001"

import requests

BASE = "https://api.griito.com"

# 1. Obtener token
token_resp = requests.post(f"{BASE}/oauth/token", data={
    "grant_type": "password",
    "client_id": "YOUR_CLIENT_ID",
    "client_secret": "YOUR_CLIENT_SECRET",
    "username": "juan@ejemplo.com",
    "password": "mi_password",
    "scope": "*"
})
token = token_resp.json()["access_token"]
headers = {"Authorization": f"Bearer {token}"}

# 2. Subir audio
with open("/ruta/a/mi_audio.mp3", "rb") as f:
    audio_resp = requests.post(f"{BASE}/audios", headers=headers,
        files={"audio": f},
        data={"name": "aviso_despacho", "description": "Aviso de despacho"}
    )
audio_id = audio_resp.json()["data"]["id"]
print(f"Audio ID: {audio_id}")

# 3. Crear llamada tipo 0
call_resp = requests.post(f"{BASE}/calls", headers=headers, data={
    "type": 0,
    "recipients": "+56912345678",
    "audio": audio_id,
    "abrid": "pedido_5001"
})
print(call_resp.json())

<?php
$base = "https://api.griito.com";

// 1. Obtener token
$ch = curl_init("$base/oauth/token");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POSTFIELDS => http_build_query([
        "grant_type"    => "password",
        "client_id"     => "YOUR_CLIENT_ID",
        "client_secret" => "YOUR_CLIENT_SECRET",
        "username"      => "juan@ejemplo.com",
        "password"      => "mi_password",
        "scope"         => "*"
    ])
]);
$token = json_decode(curl_exec($ch), true)["access_token"];
curl_close($ch);

// 2. Subir audio
$ch = curl_init("$base/audios");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer $token"],
    CURLOPT_POSTFIELDS => [
        "audio"       => new CURLFile("/ruta/a/mi_audio.mp3"),
        "name"        => "aviso_despacho",
        "description" => "Aviso de despacho"
    ]
]);
$audioId = json_decode(curl_exec($ch), true)["data"]["id"];
curl_close($ch);

// 3. Crear llamada tipo 0
$ch = curl_init("$base/calls");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer $token"],
    CURLOPT_POSTFIELDS => http_build_query([
        "type"       => 0,
        "recipients" => "+56912345678",
        "audio"      => $audioId,
        "abrid"      => "pedido_5001"
    ])
]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);

print_r($result);

const BASE = "https://api.griito.com";
const fs = require("fs");

async function main() {
  // 1. Obtener token
  const tokenResp = await fetch(`${BASE}/oauth/token`, {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
      grant_type: "password",
      client_id: "YOUR_CLIENT_ID",
      client_secret: "YOUR_CLIENT_SECRET",
      username: "juan@ejemplo.com",
      password: "mi_password",
      scope: "*"
    })
  });
  const { access_token: token } = await tokenResp.json();
  const headers = { Authorization: `Bearer ${token}` };

  // 2. Subir audio
  const form = new FormData();
  form.append("audio", new Blob([fs.readFileSync("/ruta/a/mi_audio.mp3")]), "mi_audio.mp3");
  form.append("name", "aviso_despacho");
  form.append("description", "Aviso de despacho");

  const audioResp = await fetch(`${BASE}/audios`, {
    method: "POST", headers, body: form
  });
  const { data: { id: audioId } } = await audioResp.json();
  console.log("Audio ID:", audioId);

  // 3. Crear llamada tipo 0
  const callResp = await fetch(`${BASE}/calls`, {
    method: "POST",
    headers: { ...headers, "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
      type: "0",
      recipients: "+56912345678",
      audio: String(audioId),
      abrid: "pedido_5001"
    })
  });
  console.log(await callResp.json());
}

main();

Ejemplo rápido: Llamada TTS (tipo 2, sin subir audio)

# Llamada TTS directa (asumiendo que ya tienes el token)
curl -X POST https://api.griito.com/calls \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -d "type=2" \
  -d "recipients=+56912345678" \
  -d "tts=Hola, le informamos que su pedido ha sido despachado y llegará mañana entre las 9 y las 13 horas." \
  -d "abrid=despacho_5001"

import requests

resp = requests.post("https://api.griito.com/calls",
    headers={"Authorization": "Bearer YOUR_TOKEN"},
    data={
        "type": 2,
        "recipients": "+56912345678",
        "tts": "Hola, le informamos que su pedido ha sido despachado y llegará mañana entre las 9 y las 13 horas.",
        "abrid": "despacho_5001"
    }
)
print(resp.json())

<?php
$ch = curl_init("https://api.griito.com/calls");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer YOUR_TOKEN"],
    CURLOPT_POSTFIELDS => http_build_query([
        "type"       => 2,
        "recipients" => "+56912345678",
        "tts"        => "Hola, le informamos que su pedido ha sido despachado y llegará mañana entre las 9 y las 13 horas.",
        "abrid"      => "despacho_5001"
    ])
]);
print_r(json_decode(curl_exec($ch), true));
curl_close($ch);

const resp = await fetch("https://api.griito.com/calls", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/x-www-form-urlencoded"
  },
  body: new URLSearchParams({
    type: "2",
    recipients: "+56912345678",
    tts: "Hola, le informamos que su pedido ha sido despachado y llegará mañana entre las 9 y las 13 horas.",
    abrid: "despacho_5001"
  })
});
console.log(await resp.json());