# Create Plant
Source: https://docs.damascuss.io/api-reference/endpoint/create

POST /plants
Creates a new plant in the store



# Delete Plant
Source: https://docs.damascuss.io/api-reference/endpoint/delete

DELETE /plants/{id}
Deletes a single plant based on the ID supplied



# Get Plants
Source: https://docs.damascuss.io/api-reference/endpoint/get

GET /plants
Returns all plants from the system that the user has access to



# New Plant
Source: https://docs.damascuss.io/api-reference/endpoint/webhook

WEBHOOK /plant/webhook



# Introduction
Source: https://docs.damascuss.io/api-reference/introduction

Example section for showcasing API endpoints

<Note>
  If you're not looking to build API reference documentation, you can delete
  this section by removing the api-reference folder.
</Note>

## Welcome

There are two ways to build API documentation: [OpenAPI](https://mintlify.com/docs/api-playground/openapi/setup) and [MDX components](https://mintlify.com/docs/api-playground/mdx/configuration). For the starter kit, we are using the following OpenAPI specification.

<Card title="Plant Store Endpoints" icon="leaf" href="https://github.com/mintlify/starter/blob/main/api-reference/openapi.json">
  View the OpenAPI specification file
</Card>

## Authentication

All API endpoints are authenticated using Bearer tokens and picked up from the specification file.

```json  theme={null}
"security": [
  {
    "bearerAuth": []
  }
]
```


# Autenticación
Source: https://docs.damascuss.io/developers/authentication

Guía completa sobre autenticación con la API de NotMeta

## Métodos de autenticación

NotMeta utiliza autenticación basada en tokens JWT (JSON Web Tokens) para garantizar la seguridad de las comunicaciones con la API.

## Tipos de tokens

### Token de API

El token de API es el método principal de autenticación para aplicaciones:

* **Duración**: Configurable (1 día a 1 año)
* **Permisos**: Granular por funcionalidad
* **Uso**: Recomendado para integraciones
* **Renovación**: Manual

### Token de sesión

Token temporal para sesiones de usuario:

* **Duración**: 24 horas
* **Permisos**: Basados en el usuario
* **Uso**: Interfaz web y aplicaciones móviles
* **Renovación**: Automática

## Generar token de API

### Desde el panel web

1. Inicia sesión en NotMeta
2. Ve a "Configuración" > "API"
3. Haz clic en "Generar nuevo token"
4. Configura los permisos necesarios
5. Copia y guarda el token de forma segura

### Desde la API

```bash  theme={null}
curl -X POST "https://api.notmeta.com/v1/auth/tokens" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Mi aplicación",
    "permissions": ["messages:read", "messages:write"],
    "expires_at": "2024-12-31T23:59:59Z"
  }'
```

## Uso del token

### Header de autorización

Incluye el token en el header `Authorization`:

```bash  theme={null}
curl -X GET "https://api.notmeta.com/v1/conversations" \
  -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
```

### En diferentes lenguajes

#### JavaScript

```javascript  theme={null}
const response = await fetch('https://api.notmeta.com/v1/conversations', {
  headers: {
    'Authorization': `Bearer ${process.env.NOTMETA_API_TOKEN}`,
    'Content-Type': 'application/json'
  }
});
```

#### Python

```python  theme={null}
import requests

headers = {
    'Authorization': f'Bearer {api_token}',
    'Content-Type': 'application/json'
}

response = requests.get('https://api.notmeta.com/v1/conversations', headers=headers)
```

#### PHP

```php  theme={null}
$headers = [
    'Authorization: Bearer ' . $api_token,
    'Content-Type: application/json'
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://api.notmeta.com/v1/conversations');
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
$response = curl_exec($ch);
```

## Permisos y scopes

### Conversaciones

* `conversations:read` - Leer conversaciones
* `conversations:write` - Crear y modificar conversaciones
* `conversations:delete` - Eliminar conversaciones

### Mensajes

* `messages:read` - Leer mensajes
* `messages:write` - Enviar mensajes
* `messages:delete` - Eliminar mensajes

### Usuarios

* `users:read` - Leer información de usuarios
* `users:write` - Crear y modificar usuarios
* `users:delete` - Eliminar usuarios

### Reportes

* `reports:read` - Acceder a reportes y métricas

### Webhooks

* `webhooks:read` - Leer configuración de webhooks
* `webhooks:write` - Crear y modificar webhooks
* `webhooks:delete` - Eliminar webhooks

### Configuración

* `config:read` - Leer configuración
* `config:write` - Modificar configuración

## Verificación de permisos

### Verificar token

```bash  theme={null}
curl -X GET "https://api.notmeta.com/v1/auth/verify" \
  -H "Authorization: Bearer TU_TOKEN"
```

Respuesta:

```json  theme={null}
{
  "valid": true,
  "token_type": "api",
  "permissions": ["conversations:read", "messages:write"],
  "expires_at": "2024-12-31T23:59:59Z",
  "created_at": "2024-01-01T00:00:00Z"
}
```

### Verificar permisos específicos

```javascript  theme={null}
async function hasPermission(token, permission) {
  const response = await fetch('https://api.notmeta.com/v1/auth/verify', {
    headers: {
      'Authorization': `Bearer ${token}`
    }
  });
  
  const data = await response.json();
  return data.permissions.includes(permission);
}

// Uso
const canSendMessages = await hasPermission(token, 'messages:write');
```

## Renovación de tokens

### Verificar expiración

```javascript  theme={null}
function isTokenExpired(token) {
  try {
    const payload = JSON.parse(atob(token.split('.')[1]));
    return payload.exp * 1000 < Date.now();
  } catch (error) {
    return true;
  }
}
```

### Renovar token

```bash  theme={null}
curl -X POST "https://api.notmeta.com/v1/auth/refresh" \
  -H "Authorization: Bearer TOKEN_ACTUAL" \
  -H "Content-Type: application/json"
```

## Autenticación OAuth (Futuro)

### Flujo de autorización

```mermaid  theme={null}
sequenceDiagram
    participant App as Tu Aplicación
    participant NotMeta as NotMeta API
    participant User as Usuario
    
    App->>User: Redirige a NotMeta
    User->>NotMeta: Autoriza la aplicación
    NotMeta->>App: Código de autorización
    App->>NotMeta: Intercambia código por token
    NotMeta->>App: Token de acceso
```

### Configuración OAuth

```javascript  theme={null}
const oauthUrl = `https://api.notmeta.com/oauth/authorize?` +
  `client_id=${CLIENT_ID}&` +
  `redirect_uri=${REDIRECT_URI}&` +
  `scope=${SCOPES}&` +
  `response_type=code&` +
  `state=${RANDOM_STATE}`;
```

## Mejores prácticas de seguridad

### Almacenamiento seguro

```javascript  theme={null}
// ❌ Incorrecto - Token en código
const token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...';

// ✅ Correcto - Token en variables de entorno
const token = process.env.NOTMETA_API_TOKEN;
```

### Rotación de tokens

```javascript  theme={null}
class TokenManager {
  constructor() {
    this.token = null;
    this.refreshToken = null;
    this.expiresAt = null;
  }
  
  async getValidToken() {
    if (!this.token || this.isExpired()) {
      await this.refreshToken();
    }
    return this.token;
  }
  
  isExpired() {
    return this.expiresAt && Date.now() >= this.expiresAt;
  }
  
  async refreshToken() {
    // Implementar lógica de renovación
  }
}
```

### Manejo de errores de autenticación

```javascript  theme={null}
async function makeAuthenticatedRequest(url, options = {}) {
  try {
    const response = await fetch(url, {
      ...options,
      headers: {
        ...options.headers,
        'Authorization': `Bearer ${await tokenManager.getValidToken()}`
      }
    });
    
    if (response.status === 401) {
      // Token inválido o expirado
      await tokenManager.refreshToken();
      // Reintentar con nuevo token
      return fetch(url, {
        ...options,
        headers: {
          ...options.headers,
          'Authorization': `Bearer ${await tokenManager.getValidToken()}`
        }
      });
    }
    
    return response;
  } catch (error) {
    console.error('Error de autenticación:', error);
    throw error;
  }
}
```

## Solución de problemas

### Error 401: Unauthorized

* Verifica que el token sea correcto
* Confirma que el token no haya expirado
* Revisa los permisos del token

### Error 403: Forbidden

* Verifica que el token tenga los permisos necesarios
* Confirma que la acción esté permitida para tu rol

### Token expirado

* Implementa renovación automática
* Maneja graciosamente la expiración
* Considera usar tokens de larga duración para aplicaciones

## Recursos adicionales

<Card title="Configuración inicial" icon="gear" href="/developers/setup">
  Configura tu entorno de desarrollo
</Card>

<Card title="Webhooks" icon="webhook" href="/developers/webhooks">
  Configura notificaciones en tiempo real
</Card>


# Mejores Prácticas
Source: https://docs.damascuss.io/developers/best-practices

Guía de mejores prácticas para integrar con NotMeta de manera eficiente y segura

## Arquitectura y diseño

### Principios de diseño

#### 1. Separación de responsabilidades

```javascript  theme={null}
// ❌ Incorrecto - Todo en una función
async function handleMessage(message) {
  // Validar mensaje
  if (!message.text) return;
  
  // Procesar mensaje
  const response = await processMessage(message.text);
  
  // Enviar respuesta
  await sendMessage(message.from, response);
  
  // Guardar en base de datos
  await saveToDatabase(message);
  
  // Enviar notificación
  await sendNotification(message);
}

// ✅ Correcto - Separado por responsabilidades
class MessageHandler {
  constructor(messageValidator, messageProcessor, messageSender, messageRepository, notificationService) {
    this.validator = messageValidator;
    this.processor = messageProcessor;
    this.sender = messageSender;
    this.repository = messageRepository;
    this.notificationService = notificationService;
  }
  
  async handleMessage(message) {
    if (!this.validator.isValid(message)) {
      throw new ValidationError('Invalid message');
    }
    
    const response = await this.processor.process(message);
    await this.sender.send(message.from, response);
    await this.repository.save(message);
    await this.notificationService.notify(message);
  }
}
```

#### 2. Manejo de errores robusto

```javascript  theme={null}
class NotMetaClient {
  async sendMessage(messageData) {
    try {
      return await this.makeRequest('/messages', 'POST', messageData);
    } catch (error) {
      if (error.status === 429) {
        throw new RateLimitError('Too many requests', error.retryAfter);
      } else if (error.status === 401) {
        throw new AuthenticationError('Invalid credentials');
      } else if (error.status >= 500) {
        throw new ServerError('NotMeta service unavailable');
      } else {
        throw new NotMetaError(error.message, error.status);
      }
    }
  }
}
```

#### 3. Configuración centralizada

```javascript  theme={null}
// config/notmeta.js
module.exports = {
  apiUrl: process.env.NOTMETA_API_URL || 'https://api.notmeta.com',
  apiToken: process.env.NOTMETA_API_TOKEN,
  webhookSecret: process.env.NOTMETA_WEBHOOK_SECRET,
  timeout: parseInt(process.env.NOTMETA_TIMEOUT) || 30000,
  retries: parseInt(process.env.NOTMETA_RETRIES) || 3,
  rateLimit: {
    requests: 100,
    window: 60000 // 1 minuto
  }
};
```

## Gestión de datos

### Caché inteligente

```javascript  theme={null}
class ConversationCache {
  constructor(redisClient, ttl = 300) { // 5 minutos
    this.redis = redisClient;
    this.ttl = ttl;
  }
  
  async getConversation(conversationId) {
    const cacheKey = `conversation:${conversationId}`;
    const cached = await this.redis.get(cacheKey);
    
    if (cached) {
      return JSON.parse(cached);
    }
    
    // Obtener de la API
    const conversation = await this.notMetaClient.getConversation(conversationId);
    
    // Guardar en caché
    await this.redis.setex(cacheKey, this.ttl, JSON.stringify(conversation));
    
    return conversation;
  }
  
  async invalidateConversation(conversationId) {
    const cacheKey = `conversation:${conversationId}`;
    await this.redis.del(cacheKey);
  }
}
```

### Validación de datos

```javascript  theme={null}
const Joi = require('joi');

const messageSchema = Joi.object({
  to: Joi.string().pattern(/^\d+$/).required(),
  type: Joi.string().valid('text', 'image', 'document', 'audio', 'video').required(),
  text: Joi.string().when('type', {
    is: 'text',
    then: Joi.required(),
    otherwise: Joi.forbidden()
  }),
  media: Joi.object().when('type', {
    is: Joi.string().valid('image', 'document', 'audio', 'video'),
    then: Joi.required(),
    otherwise: Joi.forbidden()
  })
});

function validateMessage(messageData) {
  const { error, value } = messageSchema.validate(messageData);
  if (error) {
    throw new ValidationError(error.details[0].message);
  }
  return value;
}
```

### Paginación eficiente

```javascript  theme={null}
class ConversationService {
  async getConversations(options = {}) {
    const params = {
      limit: Math.min(options.limit || 50, 100),
      cursor: options.cursor,
      status: options.status,
      assigned_to: options.assignedTo
    };
    
    const response = await this.notMetaClient.get('/conversations', { params });
    
    return {
      conversations: response.data,
      pagination: {
        nextCursor: response.pagination?.next_cursor,
        hasMore: response.pagination?.has_more
      }
    };
  }
  
  async getAllConversations(options = {}) {
    const allConversations = [];
    let cursor = null;
    
    do {
      const result = await this.getConversations({
        ...options,
        cursor
      });
      
      allConversations.push(...result.conversations);
      cursor = result.pagination.nextCursor;
    } while (cursor);
    
    return allConversations;
  }
}
```

## Performance y escalabilidad

### Rate limiting

```javascript  theme={null}
class RateLimiter {
  constructor(requests, windowMs) {
    this.requests = requests;
    this.windowMs = windowMs;
    this.requests = new Map();
  }
  
  async isAllowed(key) {
    const now = Date.now();
    const windowStart = now - this.windowMs;
    
    // Limpiar requests antiguos
    for (const [timestamp] of this.requests.entries()) {
      if (timestamp < windowStart) {
        this.requests.delete(timestamp);
      }
    }
    
    // Verificar límite
    if (this.requests.size >= this.requests) {
      return false;
    }
    
    // Registrar request
    this.requests.set(now, key);
    return true;
  }
}

class NotMetaClientWithRateLimit {
  constructor(rateLimiter) {
    this.rateLimiter = rateLimiter;
  }
  
  async makeRequest(url, method, data) {
    if (!await this.rateLimiter.isAllowed('api')) {
      throw new RateLimitError('Rate limit exceeded');
    }
    
    return await this.httpClient.request({ url, method, data });
  }
}
```

### Procesamiento asíncrono

```javascript  theme={null}
const Queue = require('bull');

class MessageQueue {
  constructor() {
    this.queue = new Queue('message processing', {
      redis: {
        host: process.env.REDIS_HOST,
        port: process.env.REDIS_PORT
      }
    });
    
    this.setupProcessors();
  }
  
  setupProcessors() {
    this.queue.process('send-message', 10, async (job) => {
      const { messageData } = job.data;
      return await this.notMetaClient.sendMessage(messageData);
    });
    
    this.queue.process('process-webhook', 20, async (job) => {
      const { event } = job.data;
      return await this.handleWebhookEvent(event);
    });
  }
  
  async addSendMessage(messageData, options = {}) {
    return await this.queue.add('send-message', { messageData }, {
      attempts: 3,
      backoff: 'exponential',
      ...options
    });
  }
}
```

### Circuit breaker

```javascript  theme={null}
class CircuitBreaker {
  constructor(threshold = 5, timeout = 60000) {
    this.threshold = threshold;
    this.timeout = timeout;
    this.failureCount = 0;
    this.lastFailureTime = null;
    this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
  }
  
  async execute(operation) {
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailureTime > this.timeout) {
        this.state = 'HALF_OPEN';
      } else {
        throw new CircuitBreakerOpenError('Circuit breaker is open');
      }
    }
    
    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
  
  onSuccess() {
    this.failureCount = 0;
    this.state = 'CLOSED';
  }
  
  onFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();
    
    if (this.failureCount >= this.threshold) {
      this.state = 'OPEN';
    }
  }
}
```

## Seguridad

### Validación de webhooks

```javascript  theme={null}
class WebhookValidator {
  constructor(secret) {
    this.secret = secret;
  }
  
  validate(payload, signature) {
    const expectedSignature = this.calculateSignature(payload);
    return this.secureCompare(signature, expectedSignature);
  }
  
  calculateSignature(payload) {
    const crypto = require('crypto');
    return 'sha256=' + crypto
      .createHmac('sha256', this.secret)
      .update(payload)
      .digest('hex');
  }
  
  secureCompare(a, b) {
    if (a.length !== b.length) {
      return false;
    }
    
    let result = 0;
    for (let i = 0; i < a.length; i++) {
      result |= a.charCodeAt(i) ^ b.charCodeAt(i);
    }
    
    return result === 0;
  }
}
```

### Sanitización de datos

```javascript  theme={null}
class DataSanitizer {
  static sanitizePhoneNumber(phone) {
    // Remover caracteres no numéricos
    return phone.replace(/\D/g, '');
  }
  
  static sanitizeMessage(message) {
    // Remover caracteres de control y limitar longitud
    return message
      .replace(/[\x00-\x1F\x7F]/g, '')
      .substring(0, 4096);
  }
  
  static sanitizeFileName(filename) {
    // Remover caracteres peligrosos
    return filename.replace(/[^a-zA-Z0-9._-]/g, '_');
  }
}
```

### Logging seguro

```javascript  theme={null}
class SecureLogger {
  static log(message, data = {}) {
    const sanitizedData = this.sanitizeLogData(data);
    
    console.log(JSON.stringify({
      timestamp: new Date().toISOString(),
      message,
      data: sanitizedData
    }));
  }
  
  static sanitizeLogData(data) {
    const sensitiveFields = ['token', 'secret', 'password', 'api_key'];
    const sanitized = { ...data };
    
    for (const field of sensitiveFields) {
      if (sanitized[field]) {
        sanitized[field] = '[REDACTED]';
      }
    }
    
    return sanitized;
  }
}
```

## Monitoreo y observabilidad

### Métricas personalizadas

```javascript  theme={null}
class MetricsCollector {
  constructor() {
    this.metrics = new Map();
  }
  
  increment(counter, tags = {}) {
    const key = this.getKey(counter, tags);
    this.metrics.set(key, (this.metrics.get(key) || 0) + 1);
  }
  
  timing(timer, duration, tags = {}) {
    const key = this.getKey(timer, tags);
    const timings = this.metrics.get(key) || [];
    timings.push(duration);
    this.metrics.set(key, timings);
  }
  
  getKey(name, tags) {
    const sortedTags = Object.keys(tags)
      .sort()
      .map(key => `${key}:${tags[key]}`)
      .join(',');
    
    return sortedTags ? `${name}{${sortedTags}}` : name;
  }
}

// Uso
const metrics = new MetricsCollector();

metrics.increment('messages.sent', { status: 'success' });
metrics.timing('api.response_time', 150, { endpoint: '/messages' });
```

### Health checks

```javascript  theme={null}
class HealthChecker {
  constructor(notMetaClient) {
    this.notMetaClient = notMetaClient;
  }
  
  async checkHealth() {
    const checks = {
      database: await this.checkDatabase(),
      notmeta: await this.checkNotMeta(),
      redis: await this.checkRedis()
    };
    
    const isHealthy = Object.values(checks).every(check => check.status === 'healthy');
    
    return {
      status: isHealthy ? 'healthy' : 'unhealthy',
      checks,
      timestamp: new Date().toISOString()
    };
  }
  
  async checkNotMeta() {
    try {
      await this.notMetaClient.get('/health');
      return { status: 'healthy' };
    } catch (error) {
      return { 
        status: 'unhealthy', 
        error: error.message 
      };
    }
  }
}
```

## Testing

### Tests unitarios

```javascript  theme={null}
describe('MessageHandler', () => {
  let messageHandler;
  let mockNotMetaClient;
  
  beforeEach(() => {
    mockNotMetaClient = {
      sendMessage: jest.fn(),
      getConversation: jest.fn()
    };
    
    messageHandler = new MessageHandler(mockNotMetaClient);
  });
  
  test('should send message successfully', async () => {
    const messageData = {
      to: '1234567890',
      type: 'text',
      text: 'Hello'
    };
    
    mockNotMetaClient.sendMessage.mockResolvedValue({ id: 'msg_123' });
    
    const result = await messageHandler.sendMessage(messageData);
    
    expect(mockNotMetaClient.sendMessage).toHaveBeenCalledWith(messageData);
    expect(result.id).toBe('msg_123');
  });
  
  test('should handle API errors', async () => {
    const messageData = {
      to: '1234567890',
      type: 'text',
      text: 'Hello'
    };
    
    mockNotMetaClient.sendMessage.mockRejectedValue(
      new Error('API Error')
    );
    
    await expect(messageHandler.sendMessage(messageData))
      .rejects.toThrow('API Error');
  });
});
```

### Tests de integración

```javascript  theme={null}
describe('Webhook Integration', () => {
  let app;
  let server;
  
  beforeAll(async () => {
    app = createApp();
    server = app.listen(0);
  });
  
  afterAll(async () => {
    await server.close();
  });
  
  test('should handle webhook events', async () => {
    const event = {
      id: 'evt_123',
      type: 'message.received',
      data: {
        message: {
          id: 'msg_123',
          from: '1234567890',
          text: 'Hello'
        }
      }
    };
    
    const signature = calculateWebhookSignature(event);
    
    const response = await request(app)
      .post('/webhook')
      .set('X-NotMeta-Signature', signature)
      .send(event);
    
    expect(response.status).toBe(200);
    expect(response.text).toBe('OK');
  });
});
```

## Recursos adicionales

<Card title="Introducción para desarrolladores" icon="code" href="/developers/introduction">
  Conceptos básicos de la API de NotMeta
</Card>

<Card title="API Reference" icon="book" href="/api-reference/introduction">
  Documentación completa de la API
</Card>


# Introducción para Desarrolladores
Source: https://docs.damascuss.io/developers/introduction

Guía técnica para desarrolladores que integren NotMeta con sus sistemas

<Warning>
  Esta sección está en **BETA**. NotMeta está siendo expuesta como infraestructura para el desarrollo de aplicaciones que utilicen WhatsApp. Nuestra propuesta es: **Integra WhatsApp en tus apps en 1 día o 1 hora**.
</Warning>

## NotMeta API

NotMeta proporciona una API RESTful completa para integrar la gestión de WhatsApp Business con tus sistemas existentes. La API permite gestionar conversaciones, usuarios, reportes y configuraciones programáticamente.

## Características de la API

### Endpoints principales

* **Conversaciones**: Gestión completa de chats y mensajes
* **Usuarios**: Administración de equipo y permisos
* **Webhooks**: Notificaciones en tiempo real
* **Reportes**: Métricas y análisis de datos
* **Configuración**: Gestión de ajustes del sistema

### Autenticación

NotMeta utiliza autenticación basada en tokens JWT para garantizar la seguridad de las integraciones.

### Rate Limiting

La API incluye límites de velocidad para proteger la estabilidad del sistema y garantizar un rendimiento óptimo.

## Arquitectura del sistema

### Componentes principales

* **API Gateway**: Punto de entrada para todas las solicitudes
* **Servicio de Conversaciones**: Gestión de mensajes y chats
* **Servicio de Usuarios**: Autenticación y autorización
* **Servicio de Webhooks**: Notificaciones en tiempo real
* **Base de datos**: Almacenamiento de datos y métricas

### Integración con WhatsApp Business API

NotMeta actúa como intermediario entre tu aplicación y la WhatsApp Business API de Meta, proporcionando:

* Gestión de múltiples usuarios
* Herramientas de colaboración
* Análisis y reportes
* Interfaz de usuario familiar

## Flujo de datos

```mermaid  theme={null}
graph TD
    A[Tu Aplicación] --> B[NotMeta API]
    B --> C[WhatsApp Business API]
    B --> D[Base de Datos]
    B --> E[Webhooks]
    E --> A
    
    F[Cliente WhatsApp] --> C
    C --> B
    B --> A
```

## Casos de uso comunes

### Integración con CRM

* Sincronizar contactos entre sistemas
* Crear tickets automáticamente desde conversaciones
* Actualizar información de clientes
* Generar reportes unificados

### Automatización de respuestas

* Respuestas automáticas basadas en palabras clave
* Enrutamiento inteligente de conversaciones
* Escalamiento automático de casos complejos
* Integración con chatbots

### Análisis y reportes

* Extraer métricas de rendimiento
* Generar reportes personalizados
* Integrar datos con herramientas de BI
* Monitoreo en tiempo real

### Notificaciones

* Alertas de nuevas conversaciones
* Notificaciones de mensajes urgentes
* Recordatorios de seguimiento
* Integración con sistemas de tickets

## Requisitos técnicos

### Lenguajes soportados

* JavaScript/Node.js
* Python
* PHP
* Java
* C#
* Go
* Ruby

### Formatos de datos

* JSON para todas las respuestas
* UTF-8 para codificación de caracteres
* ISO 8601 para fechas y horas
* Base64 para archivos multimedia

### Protocolos

* HTTPS obligatorio para todas las comunicaciones
* WebSockets para notificaciones en tiempo real
* HTTP/2 soportado para mejor rendimiento

## Próximos pasos

<Card title="Configuración inicial" icon="gear" href="/developers/setup" horizontal>
  Configura tu entorno de desarrollo y obtén tus credenciales de API.
</Card>

<Card title="Autenticación" icon="key" href="/developers/authentication" horizontal>
  Aprende cómo autenticarte con la API de NotMeta.
</Card>

## Recursos adicionales

* [Documentación completa de la API](/api-reference/introduction)
* [SDK oficiales](https://github.com/notmeta/sdks)
* [Ejemplos de código](https://github.com/notmeta/examples)
* [Soporte técnico](mailto:contact@damascuss.io)


# Configuración Inicial
Source: https://docs.damascuss.io/developers/setup

Configura tu entorno de desarrollo para integrar con NotMeta

## Requisitos previos

### Cuenta de NotMeta

* Cuenta de NotMeta activa
* Acceso de administrador o desarrollador
* WhatsApp Business API configurado

### Herramientas de desarrollo

* Cliente HTTP (Postman, curl, etc.)
* Editor de código
* Navegador web
* Acceso a terminal/consola

## Obtener credenciales de API

### 1. Acceder al panel de desarrolladores

1. Inicia sesión en tu cuenta de NotMeta
2. Ve a "Configuración" > "API"
3. Haz clic en "Generar token de API"

### 2. Configurar permisos

Selecciona los permisos necesarios para tu aplicación:

* **Conversaciones**: Leer y escribir mensajes
* **Usuarios**: Gestionar equipo
* **Reportes**: Acceder a métricas
* **Webhooks**: Configurar notificaciones
* **Configuración**: Modificar ajustes

### 3. Generar token

1. Ingresa un nombre descriptivo para tu token
2. Selecciona la fecha de expiración
3. Haz clic en "Generar token"
4. **Importante**: Copia y guarda el token de forma segura

## Configuración del entorno

### Variables de entorno

Crea un archivo `.env` con tus credenciales:

```bash  theme={null}
NOTMETA_API_URL=https://api.notmeta.com
NOTMETA_API_TOKEN=tu_token_aqui
NOTMETA_WEBHOOK_SECRET=tu_secret_webhook
```

### Configuración de HTTPS

Para desarrollo local, puedes usar un túnel HTTPS:

```bash  theme={null}
# Usando ngrok
ngrok http 3000

# Usando localtunnel
npx localtunnel --port 3000
```

## Primeras llamadas a la API

### Verificar conexión

```bash  theme={null}
curl -X GET "https://api.notmeta.com/v1/health" \
  -H "Authorization: Bearer TU_TOKEN_AQUI" \
  -H "Content-Type: application/json"
```

### Obtener información de la cuenta

```bash  theme={null}
curl -X GET "https://api.notmeta.com/v1/account" \
  -H "Authorization: Bearer TU_TOKEN_AQUI" \
  -H "Content-Type: application/json"
```

## Configuración de webhooks

### 1. Crear endpoint webhook

```javascript  theme={null}
const express = require('express');
const app = express();

app.post('/webhook', (req, res) => {
  const signature = req.headers['x-notmeta-signature'];
  const payload = JSON.stringify(req.body);
  
  // Verificar firma del webhook
  if (verifyWebhookSignature(payload, signature)) {
    // Procesar evento
    handleWebhookEvent(req.body);
    res.status(200).send('OK');
  } else {
    res.status(400).send('Invalid signature');
  }
});

function verifyWebhookSignature(payload, signature) {
  const crypto = require('crypto');
  const expectedSignature = crypto
    .createHmac('sha256', process.env.NOTMETA_WEBHOOK_SECRET)
    .update(payload)
    .digest('hex');
  
  return signature === `sha256=${expectedSignature}`;
}
```

### 2. Registrar webhook

```bash  theme={null}
curl -X POST "https://api.notmeta.com/v1/webhooks" \
  -H "Authorization: Bearer TU_TOKEN_AQUI" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://tu-dominio.com/webhook",
    "events": ["message.received", "conversation.assigned"]
  }'
```

## SDKs oficiales

### JavaScript/Node.js

```bash  theme={null}
npm install @notmeta/sdk
```

```javascript  theme={null}
const NotMeta = require('@notmeta/sdk');

const client = new NotMeta({
  apiToken: process.env.NOTMETA_API_TOKEN
});

// Enviar mensaje
const message = await client.messages.send({
  to: '1234567890',
  type: 'text',
  text: 'Hola, ¿cómo puedo ayudarte?'
});
```

### Python

```bash  theme={null}
pip install notmeta-sdk
```

```python  theme={null}
from notmeta import NotMeta

client = NotMeta(api_token='tu_token_aqui')

# Enviar mensaje
message = client.messages.send(
    to='1234567890',
    type='text',
    text='Hola, ¿cómo puedo ayudarte?'
)
```

### PHP

```bash  theme={null}
composer require notmeta/notmeta-php
```

```php  theme={null}
<?php
use NotMeta\NotMeta;

$client = new NotMeta([
    'api_token' => 'tu_token_aqui'
]);

// Enviar mensaje
$message = $client->messages->send([
    'to' => '1234567890',
    'type' => 'text',
    'text' => 'Hola, ¿cómo puedo ayudarte?'
]);
?>
```

## Herramientas de desarrollo

### Postman Collection

Importa nuestra colección de Postman para probar la API:

1. Descarga la colección desde [GitHub](https://github.com/notmeta/postman)
2. Importa en Postman
3. Configura las variables de entorno:
   * `base_url`: [https://api.notmeta.com](https://api.notmeta.com)
   * `api_token`: Tu token de API

### Testing

```javascript  theme={null}
// Ejemplo de test con Jest
const NotMeta = require('@notmeta/sdk');

describe('NotMeta API', () => {
  let client;
  
  beforeAll(() => {
    client = new NotMeta({
      apiToken: process.env.NOTMETA_API_TOKEN
    });
  });
  
  test('should send message', async () => {
    const response = await client.messages.send({
      to: '1234567890',
      type: 'text',
      text: 'Test message'
    });
    
    expect(response.id).toBeDefined();
  });
});
```

## Mejores prácticas

### Seguridad

* Nunca hardcodees tokens en el código
* Usa variables de entorno para credenciales
* Implementa verificación de firmas de webhooks
* Usa HTTPS en producción

### Manejo de errores

```javascript  theme={null}
try {
  const response = await client.messages.send(messageData);
} catch (error) {
  if (error.status === 401) {
    // Token inválido
    console.error('Error de autenticación');
  } else if (error.status === 429) {
    // Rate limit excedido
    console.error('Demasiadas solicitudes');
  } else {
    console.error('Error inesperado:', error.message);
  }
}
```

### Rate limiting

```javascript  theme={null}
// Implementar retry con backoff exponencial
async function sendWithRetry(messageData, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await client.messages.send(messageData);
    } catch (error) {
      if (error.status === 429 && i < maxRetries - 1) {
        const delay = Math.pow(2, i) * 1000;
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
}
```

## Solución de problemas

### Error 401: Unauthorized

* Verifica que tu token sea válido
* Confirma que el token no haya expirado
* Revisa los permisos asignados al token

### Error 429: Too Many Requests

* Implementa backoff exponencial
* Reduce la frecuencia de las solicitudes
* Considera usar webhooks en lugar de polling

### Error 500: Internal Server Error

* Verifica el formato de tu solicitud
* Contacta soporte técnico si persiste
* Revisa el estado del servicio

## Recursos adicionales

<Card title="Autenticación" icon="key" href="/developers/authentication">
  Aprende sobre los diferentes métodos de autenticación
</Card>

<Card title="Webhooks" icon="webhook" href="/developers/webhooks">
  Configura notificaciones en tiempo real
</Card>


# Webhooks
Source: https://docs.damascuss.io/developers/webhooks

Configura notificaciones en tiempo real con webhooks de NotMeta

## ¿Qué son los webhooks?

Los webhooks son notificaciones HTTP que NotMeta envía a tu aplicación cuando ocurren eventos específicos. Esto te permite reaccionar en tiempo real a cambios en conversaciones, mensajes y usuarios.

## Eventos disponibles

### Conversaciones

* `conversation.created` - Nueva conversación creada
* `conversation.assigned` - Conversación asignada a un usuario
* `conversation.unassigned` - Conversación desasignada
* `conversation.closed` - Conversación cerrada
* `conversation.reopened` - Conversación reabierta

### Mensajes

* `message.received` - Nuevo mensaje recibido
* `message.sent` - Mensaje enviado
* `message.delivered` - Mensaje entregado
* `message.read` - Mensaje leído
* `message.failed` - Error al enviar mensaje

### Usuarios

* `user.created` - Nuevo usuario creado
* `user.updated` - Usuario actualizado
* `user.deleted` - Usuario eliminado
* `user.online` - Usuario conectado
* `user.offline` - Usuario desconectado

### Sistema

* `webhook.verified` - Webhook verificado
* `webhook.failed` - Error en webhook

## Configurar webhooks

### Crear webhook

```bash  theme={null}
curl -X POST "https://api.notmeta.com/v1/webhooks" \
  -H "Authorization: Bearer TU_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://tu-dominio.com/webhook",
    "events": ["message.received", "conversation.assigned"],
    "secret": "tu_secret_webhook"
  }'
```

### Respuesta

```json  theme={null}
{
  "id": "wh_123456789",
  "url": "https://tu-dominio.com/webhook",
  "events": ["message.received", "conversation.assigned"],
  "secret": "whsec_abc123...",
  "created_at": "2024-01-01T00:00:00Z",
  "status": "active"
}
```

## Estructura de eventos

### Evento de mensaje recibido

```json  theme={null}
{
  "id": "evt_123456789",
  "type": "message.received",
  "created_at": "2024-01-01T12:00:00Z",
  "data": {
    "message": {
      "id": "msg_123456789",
      "conversation_id": "conv_123456789",
      "from": "1234567890",
      "to": "0987654321",
      "type": "text",
      "text": "Hola, necesito ayuda",
      "timestamp": "2024-01-01T12:00:00Z"
    },
    "conversation": {
      "id": "conv_123456789",
      "status": "open",
      "assigned_to": null,
      "created_at": "2024-01-01T11:55:00Z"
    }
  }
}
```

### Evento de conversación asignada

```json  theme={null}
{
  "id": "evt_123456790",
  "type": "conversation.assigned",
  "created_at": "2024-01-01T12:05:00Z",
  "data": {
    "conversation": {
      "id": "conv_123456789",
      "status": "assigned",
      "assigned_to": "user_123456789",
      "assigned_at": "2024-01-01T12:05:00Z"
    },
    "user": {
      "id": "user_123456789",
      "name": "Juan Pérez",
      "email": "juan@empresa.com",
      "role": "agent"
    }
  }
}
```

## Implementar endpoint webhook

### Node.js con Express

```javascript  theme={null}
const express = require('express');
const crypto = require('crypto');
const app = express();

app.use(express.json());

app.post('/webhook', (req, res) => {
  const signature = req.headers['x-notmeta-signature'];
  const payload = JSON.stringify(req.body);
  
  // Verificar firma
  if (!verifySignature(payload, signature)) {
    return res.status(400).send('Invalid signature');
  }
  
  // Procesar evento
  const event = req.body;
  handleWebhookEvent(event);
  
  res.status(200).send('OK');
});

function verifySignature(payload, signature) {
  const secret = process.env.NOTMETA_WEBHOOK_SECRET;
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');
  
  return signature === `sha256=${expectedSignature}`;
}

function handleWebhookEvent(event) {
  switch (event.type) {
    case 'message.received':
      handleNewMessage(event.data.message);
      break;
    case 'conversation.assigned':
      handleConversationAssigned(event.data.conversation);
      break;
    default:
      console.log(`Evento no manejado: ${event.type}`);
  }
}

function handleNewMessage(message) {
  console.log(`Nuevo mensaje de ${message.from}: ${message.text}`);
  // Tu lógica aquí
}

function handleConversationAssigned(conversation) {
  console.log(`Conversación ${conversation.id} asignada a ${conversation.assigned_to}`);
  // Tu lógica aquí
}

app.listen(3000, () => {
  console.log('Webhook server running on port 3000');
});
```

### Python con Flask

```python  theme={null}
from flask import Flask, request, jsonify
import hmac
import hashlib
import json

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def webhook():
    signature = request.headers.get('X-NotMeta-Signature')
    payload = request.get_data()
    
    # Verificar firma
    if not verify_signature(payload, signature):
        return 'Invalid signature', 400
    
    # Procesar evento
    event = request.json
    handle_webhook_event(event)
    
    return 'OK', 200

def verify_signature(payload, signature):
    secret = os.environ.get('NOTMETA_WEBHOOK_SECRET')
    expected_signature = hmac.new(
        secret.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    
    return signature == f'sha256={expected_signature}'

def handle_webhook_event(event):
    event_type = event['type']
    
    if event_type == 'message.received':
        handle_new_message(event['data']['message'])
    elif event_type == 'conversation.assigned':
        handle_conversation_assigned(event['data']['conversation'])
    else:
        print(f'Evento no manejado: {event_type}')

def handle_new_message(message):
    print(f'Nuevo mensaje de {message["from"]}: {message["text"]}')
    # Tu lógica aquí

def handle_conversation_assigned(conversation):
    print(f'Conversación {conversation["id"]} asignada')
    # Tu lógica aquí

if __name__ == '__main__':
    app.run(port=3000)
```

### PHP

```php  theme={null}
<?php
// webhook.php

$secret = $_ENV['NOTMETA_WEBHOOK_SECRET'];
$signature = $_SERVER['HTTP_X_NOTMETA_SIGNATURE'];
$payload = file_get_contents('php://input');

// Verificar firma
if (!verifySignature($payload, $signature, $secret)) {
    http_response_code(400);
    echo 'Invalid signature';
    exit;
}

// Procesar evento
$event = json_decode($payload, true);
handleWebhookEvent($event);

echo 'OK';

function verifySignature($payload, $signature, $secret) {
    $expectedSignature = 'sha256=' . hash_hmac('sha256', $payload, $secret);
    return hash_equals($expectedSignature, $signature);
}

function handleWebhookEvent($event) {
    $eventType = $event['type'];
    
    switch ($eventType) {
        case 'message.received':
            handleNewMessage($event['data']['message']);
            break;
        case 'conversation.assigned':
            handleConversationAssigned($event['data']['conversation']);
            break;
        default:
            error_log("Evento no manejado: $eventType");
    }
}

function handleNewMessage($message) {
    error_log("Nuevo mensaje de {$message['from']}: {$message['text']}");
    // Tu lógica aquí
}

function handleConversationAssigned($conversation) {
    error_log("Conversación {$conversation['id']} asignada");
    // Tu lógica aquí
}
?>
```

## Verificación de webhooks

### Verificación automática

Cuando creas un webhook, NotMeta envía un evento de verificación:

```json  theme={null}
{
  "id": "evt_verify_123",
  "type": "webhook.verified",
  "created_at": "2024-01-01T00:00:00Z",
  "data": {
    "webhook_id": "wh_123456789",
    "challenge": "challenge_string_123"
  }
}
```

### Responder al desafío

```javascript  theme={null}
app.post('/webhook', (req, res) => {
  if (req.body.type === 'webhook.verified') {
    // Responder al desafío de verificación
    return res.status(200).send(req.body.data.challenge);
  }
  
  // Procesar otros eventos...
});
```

## Manejo de errores

### Reintentos automáticos

NotMeta reintenta automáticamente webhooks que fallan:

* **Primer reintento**: 1 minuto
* **Segundo reintento**: 5 minutos
* **Tercer reintento**: 15 minutos
* **Cuarto reintento**: 1 hora
* **Máximo**: 4 reintentos

### Manejo de errores en tu endpoint

```javascript  theme={null}
app.post('/webhook', async (req, res) => {
  try {
    // Procesar evento
    await handleWebhookEvent(req.body);
    res.status(200).send('OK');
  } catch (error) {
    console.error('Error procesando webhook:', error);
    
    // Para errores temporales, devolver 5xx
    if (isTemporaryError(error)) {
      res.status(503).send('Service Unavailable');
    } else {
      // Para errores permanentes, devolver 4xx
      res.status(400).send('Bad Request');
    }
  }
});
```

## Mejores prácticas

### Idempotencia

```javascript  theme={null}
const processedEvents = new Set();

function handleWebhookEvent(event) {
  // Evitar procesar el mismo evento dos veces
  if (processedEvents.has(event.id)) {
    console.log(`Evento ${event.id} ya procesado`);
    return;
  }
  
  // Procesar evento
  processEvent(event);
  
  // Marcar como procesado
  processedEvents.add(event.id);
}
```

### Procesamiento asíncrono

```javascript  theme={null}
const Queue = require('bull');
const webhookQueue = new Queue('webhook processing');

app.post('/webhook', (req, res) => {
  // Verificar firma
  if (!verifySignature(req.body, req.headers['x-notmeta-signature'])) {
    return res.status(400).send('Invalid signature');
  }
  
  // Agregar a cola para procesamiento asíncrono
  webhookQueue.add('process-event', req.body);
  
  res.status(200).send('OK');
});

webhookQueue.process('process-event', async (job) => {
  const event = job.data;
  await handleWebhookEvent(event);
});
```

### Logging

```javascript  theme={null}
function logWebhookEvent(event) {
  console.log(JSON.stringify({
    timestamp: new Date().toISOString(),
    event_id: event.id,
    event_type: event.type,
    webhook_url: req.url
  }));
}
```

## Monitoreo y debugging

### Estado de webhooks

```bash  theme={null}
curl -X GET "https://api.notmeta.com/v1/webhooks" \
  -H "Authorization: Bearer TU_TOKEN"
```

### Logs de webhook

```bash  theme={null}
curl -X GET "https://api.notmeta.com/v1/webhooks/wh_123456789/logs" \
  -H "Authorization: Bearer TU_TOKEN"
```

### Estadísticas de webhooks

```bash  theme={null}
curl -X GET "https://api.notmeta.com/v1/webhooks/wh_123456789/stats" \
  -H "Authorization: Bearer TU_TOKEN"
```

## Solución de problemas

### Webhook no recibe eventos

1. Verifica que la URL sea accesible desde internet
2. Confirma que uses HTTPS en producción
3. Revisa los logs del webhook en NotMeta
4. Verifica que los eventos estén configurados correctamente

### Errores de firma

1. Confirma que el secret sea correcto
2. Verifica que uses el payload completo
3. Revisa la codificación (UTF-8)

### Timeouts

1. Asegúrate de responder rápidamente (máximo 30 segundos)
2. Usa procesamiento asíncrono para tareas pesadas
3. Implementa circuit breakers para servicios externos

## Recursos adicionales

<Card title="Configuración inicial" icon="gear" href="/developers/setup">
  Configura tu entorno de desarrollo
</Card>

<Card title="Mejores prácticas" icon="star" href="/developers/best-practices">
  Aprende las mejores prácticas para integrar con NotMeta
</Card>


# Información del negocio
Source: https://docs.damascuss.io/users/business-info

Configura los datos de tu negocio para potenciar las funcionalidades inteligentes de NotMeta

## ¿Qué es la información del negocio?

La sección de **Negocio** centraliza los datos básicos de tu empresa para que NotMeta pueda entender tu contexto y asistirte mejor. Completar esta información permite habilitar funcionalidades inteligentes y mejorar la precisión de las respuestas.

## ¿Por qué es importante?

* **Mejor comprensión de tu empresa**: NotMeta utiliza la información de tu negocio (nombre, descripción y documentos) para generar respuestas más precisas y contextualizadas. Esto permite que el sistema comprenda mejor tu industria, servicios, horarios de atención y políticas específicas, resultando en interacciones más naturales y relevantes con tus clientes.
* **Funciones inteligentes**: Se activan asistentes que responden preguntas frecuentes (por ejemplo, horarios) y ayudan a pulir mensajes antes de enviarlos.
* **Escalabilidad futura**: A partir de esta información podremos habilitar más automatizaciones y recomendaciones.

## Acceso desde el home

Desde el home de NotMeta, entra a la tarjeta **Negocio**:

<img src="https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-1.png?fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=3b58d11fd5a3e654d371c38e582baa14" alt="Acceso a la sección Negocio desde el home" data-og-width="960" width="960" data-og-height="720" height="720" data-path="images/business/business-1.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-1.png?w=280&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=2d32549cc43fe1a848fb2983f5d26a5b 280w, https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-1.png?w=560&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=1204842571ca8f5d9b38adba2056ae84 560w, https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-1.png?w=840&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=7faed5f57c306ea2f1823664c3d6adc5 840w, https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-1.png?w=1100&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=e02adf0bfc7020404a79c12bc24b5001 1100w, https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-1.png?w=1650&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=c69c059a7736ce2b74af13b643519614 1650w, https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-1.png?w=2500&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=e5ff95a5cfc5ee7134b34ad6247e648a 2500w" />

## Configuración paso a paso

La pantalla de configuración luce así:

<img src="https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-2.png?fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=d41aa9b42cab008a3dc191fb65bc3871" alt="Pantalla de Información del Negocio" data-og-width="960" width="960" data-og-height="720" height="720" data-path="images/business/business-2.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-2.png?w=280&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=e0023ec22eb212c68f884f1603649cc7 280w, https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-2.png?w=560&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=35d1bf37fb030c89667c09083881ce1a 560w, https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-2.png?w=840&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=c8692a5f552b8708b309ea32a3a24fb0 840w, https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-2.png?w=1100&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=ae40bb44f5650f96a060f0ace8239564 1100w, https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-2.png?w=1650&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=e71365f3ea195922456a3c4be1d59340 1650w, https://mintcdn.com/damascuss/2TCmyvtwKmXnGvT1/images/business/business-2.png?w=2500&fit=max&auto=format&n=2TCmyvtwKmXnGvT1&q=85&s=5c82641f1def4af5594f6d6db48587a1 2500w" />

### 1. Nombre del Negocio

Ingresa el nombre con el que tus clientes reconocen a tu empresa. Esto se usa en plantillas, mensajes automáticos y reportes.

### 2. Descripción del negocio

Describe brevemente tus productos/servicios, cobertura, horarios y políticas clave. Esta información nutre al asistente para responder preguntas comunes con más precisión.

Sugerencias para la descripción:

* Incluye qué ofreces y para quién
* Horarios de atención (días y rangos horarios)
* Zonas de cobertura o sucursales
* Canales de contacto alternativos (email, web)

### 3. Documentos PDF

Adjunta documentos relevantes (catálogo, políticas, listas de precios, manuales). El sistema puede utilizarlos como referencia para ofrecer mejores respuestas y guías internas a tu equipo.

> Recomendación: usa documentos actualizados, con títulos y secciones claras.

## Funcionalidades inteligentes disponibles

En la parte derecha verás funciones que pueden activarse automáticamente a partir de tu información:

* **Responder preguntas sobre horario de atención**: El asistente responde de forma automática cuando un cliente consulta por horarios, basándose en lo configurado en tu perfil.
* **Pulir mensaje para enviar**: Mejora automáticamente la redacción de mensajes para que sean claros y profesionales (conciso, normal o explicativo).

Estas funciones se irán ampliando con más capacidades a futuro, aprovechando tus datos y documentos.

## Mejores prácticas

* Mantén el nombre y la descripción siempre actualizados
* Sube PDFs en versiones recientes y con información válida
* Revisa periódicamente que los horarios de atención estén correctos
* Registra políticas clave (cambios, entregas, devoluciones) para respuestas más precisas

## Próximos pasos

<Columns cols={2}>
  <Card title="Integra a tu equipo" icon="users" href="/users/team-collaboration">
    Agrega usuarios y define roles para colaborar en atención al cliente.
  </Card>

  <Card title="Primeros Pasos" icon="rocket" href="/users/getting-started">
    Conecta tu número de WhatsApp Business y comienza a operar.
  </Card>
</Columns>


# Preguntas Frecuentes
Source: https://docs.damascuss.io/users/faq

Respuestas a las preguntas más comunes sobre NotMeta

## Preguntas generales

### ¿Qué es NotMeta?

NotMeta es una plataforma que permite que múltiples empleados gestionen el mismo número de WhatsApp Business simultáneamente. Con una interfaz familiar similar a WhatsApp, facilita la colaboración en equipo para la atención al cliente.

### ¿Cómo funciona NotMeta?

NotMeta se conecta a tu WhatsApp Business API y permite que tu equipo acceda a todas las conversaciones desde una interfaz web. Cada miembro puede gestionar conversaciones asignadas, colaborar en casos complejos y acceder a herramientas de análisis.

### ¿Qué es Damascuss y cuál es su relación con NotMeta?

Damascuss es una fábrica de software que se especializa en la creación de productos propios como un hub de productos. Nos referimos a nosotros mismos de forma graciosa como "la fábrica de damascos" porque cada producto de Damascuss es una suculenta fruta 🍑. NotMeta es uno de nuestros productos más sabrosos, por eso lo verás de vez en cuando por ahí en la plataforma.

### ¿Es seguro usar NotMeta?

Sí, somos proveedores de tecnología oficiales de Meta y cumplimos todos sus estándares de seguridad y más. Meta valida regularmente la seguridad de los proveedores para garantizar el cumplimiento de sus políticas. Utilizamos cifrado de extremo a extremo para garantizar la seguridad de los datos enviados y recepcionados, y siempre estamos mejorando nuestros protocolos de seguridad para ofrecer la máxima protección.

## Configuración y setup

### ¿Qué necesito para usar NotMeta?

* Un número de WhatsApp Business
* Promovemos el uso de coexistencia que provee una integración mucho más simple sin perder el acceso al número desde la app
* No es necesario tener un equipo de 3 personas, pero NotMeta está hecho para colaborar
* Generalmente es más útil para empresas con varios empleados como agentes de venta o customer support
* Conexión a internet estable

### ¿Cuánto tiempo toma la configuración?

La configuración inicial toma aproximadamente 15-30 minutos. Esto incluye:

* Conexión a WhatsApp Business API
* Configuración de usuarios
* Asignación de roles
* Pruebas básicas

### ¿Puedo usar mi número personal de WhatsApp?

No, pero puedes transformarlo en una cuenta Business descargando la app y realizando el proceso de migración que es muy simple. Hecho esto ya puedes utilizar NotMeta.

### ¿Necesito conocimientos técnicos?

No, NotMeta está diseñado para ser fácil de usar. La interfaz es familiar y similar a WhatsApp. Sin embargo, la configuración inicial puede requerir asistencia técnica.

## Funcionalidades

### ¿Cuántas personas pueden usar NotMeta simultáneamente?

No hay límite en el número de usuarios que pueden usar NotMeta simultáneamente. La plataforma está diseñada para escalar según las necesidades de tu empresa.

### ¿Puedo ver el historial de conversaciones?

Sí, NotMeta mantiene un historial completo de todas las conversaciones. Puedes acceder a conversaciones pasadas, buscar por contenido y descargar reportes.

### ¿Cómo se asignan las conversaciones?

Por el momento todos pueden acceder a todos los chats de todos los contactos y responder, pero cada mensaje enviado es registrado a nombre del usuario que envía por lo que puedes ver quién está conversando y gestionando la conversación siempre.

### ¿Puedo usar plantillas de respuesta?

Sí, NotMeta incluye un sistema de plantillas que puedes personalizar. Esto acelera las respuestas a consultas comunes y mantiene consistencia en la comunicación.

### ¿Hay límites en el número de mensajes?

No, solo cobramos por el procesamiento de los mensajes pero no limitamos el envío. Es importante entender que debe estar asociada una tarjeta de crédito y debe ser pagada la cuenta de WhatsApp Business ya que en caso contrario Meta puede imponer limitaciones como no poder enviar templates o mensajes iniciales. Esto puede cambiar ya que Meta actualiza sus políticas de uso cada cierto tiempo.

## Equipo y usuarios

### ¿Qué roles están disponibles?

NotMeta maneja dos tipos de roles principales:

* **Administrador**: Puede gestionar usuarios, configurar integraciones de números de WhatsApp, editar información del negocio y tiene control total del sistema
* **Agente**: Usuario limitado a funcionalidades de contactos y chats, ideal para empleados ya que permite conversar por chat y gestionar contactos sin acceso a configuraciones administrativas

Para más detalles sobre cómo gestionar usuarios y roles, consulta nuestra guía completa en [Integra a tu equipo](/users/team-collaboration).

### ¿Puedo cambiar los roles de los usuarios?

Sí, los administradores pueden cambiar los roles y permisos de cualquier usuario en cualquier momento.

### ¿Qué pasa si un empleado se va?

Los administradores pueden desactivar o eliminar usuarios. Las conversaciones asignadas se pueden reasignar automáticamente o manualmente.

## Problemas técnicos

### ¿Qué hago si no puedo enviar mensajes?

1. Verifica tu conexión a internet
2. Comprueba el estado de WhatsApp Business API
3. Contacta soporte técnico si el problema persiste

### ¿Puedo usar NotMeta en móvil?

Contamos con apps móviles específicas para Android y iPhone y recomendamos su uso en vez de la interfaz web para móvil.

### ¿Qué pasa si se cae la conexión?

NotMeta mantiene un registro de todas las conversaciones. Cuando se restablezca la conexión, podrás ver todos los mensajes que llegaron durante la interrupción.

### ¿Puedo hacer backup de mis datos?

NotMeta realiza backups constantes, nunca perderás tus datos.

## Costos y facturación

### ¿Cómo funciona la facturación?

Los costos de mensajes se manejan a través de tu cuenta de WhatsApp Business API con Meta. NotMeta cobra una tarifa de suscripción por el uso de la plataforma.

### ¿Hay costos ocultos?

No, todos los costos están claramente especificados. Solo pagas por el uso de la plataforma y los mensajes según tu plan de WhatsApp Business API.

### ¿Puedo cancelar mi suscripción?

Sí, solo habla con nosotros.

## Soporte

### ¿Cómo obtengo soporte técnico?

Puedes contactar soporte a través de:

* Email: [contact@damascuss.io](mailto:contact@damascuss.io)
* WhatsApp: +56 9 4474 1008
* Chat en vivo en la plataforma
* Documentación y guías

### ¿Cuáles son los horarios de soporte?

El soporte está disponible durante horario comercial (Lunes a Viernes, 9 AM - 6 PM). Para casos urgentes, tenemos soporte de emergencia.

### ¿Ofrecen capacitación para mi equipo?

Sí, ofrecemos sesiones de capacitación personalizadas y recursos de aprendizaje en línea para tu equipo.

## Programa piloto

### ¿Están en programa piloto?

Sí, actualmente estamos en fase piloto buscando empresas colaboradoras.

### ¿Qué incluye el programa piloto?

* Acceso gratuito durante la fase piloto
* Configuración y soporte personalizado
* Influencia directa en el desarrollo del producto
* Descuentos preferenciales al lanzamiento oficial

### ¿Cómo puedo participar en el programa piloto?

Contacta a nuestro equipo en [contact@damascuss.io](mailto:contact@damascuss.io) para más información sobre cómo participar.

¿No encuentras la respuesta que buscas? [Contáctanos](mailto:contact@damascuss.io) y te ayudaremos.


# Primeros Pasos
Source: https://docs.damascuss.io/users/getting-started

Configura tu cuenta de NotMeta y conecta tu número de WhatsApp Business en minutos

## Cómo funciona NotMeta

Tres simples pasos para transformar tu gestión de WhatsApp Business:

### 1. Conecta tu número

Integra tu número de WhatsApp Business usando el flujo de Embedded Signup de Meta. Proceso simplificado que te permite activar el modo coexistencia.

### 2. Invita a tu equipo

Agrega a tus empleados y asigna roles y permisos según sus responsabilidades.

### 3. Gestiona conversaciones

Tu equipo puede gestionar múltiples conversaciones simultáneamente desde una interfaz familiar.

## Configuración inicial

### Paso 1: Crear cuenta en NotMeta

1. Visita [NotMeta](https://www.notmeta.damascuss.io)
2. Haz clic en "Iniciar sesión" o "Registrarse"
3. Completa la información de tu empresa
4. Verifica tu cuenta por email

### Paso 2: Conectar tu número de WhatsApp

Una vez dentro de NotMeta, sigue estos pasos para integrar tu número de WhatsApp Business:

#### Navegación inicial

Desde el home de NotMeta, navega a la sección de configuración:

<img src="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/home-notmeta.png?fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=bae6b17795dc8621ac0411fca0185fd8" alt="Navegación desde el home" data-og-width="1501" width="1501" data-og-height="879" height="879" data-path="images/notmeta_whastapp_integration/home-notmeta.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/home-notmeta.png?w=280&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=170bdf2a402f0aa4cfd79ee180e17d84 280w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/home-notmeta.png?w=560&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=131f982f45457fe91bb78cd9d5cac01e 560w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/home-notmeta.png?w=840&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=08b57c16d63d340a1978dcde5ff6fd0c 840w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/home-notmeta.png?w=1100&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=657c5dce10fd97f0f490b726870a2e2e 1100w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/home-notmeta.png?w=1650&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=8134e485f16be0387178b2d25c5775c8 1650w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/home-notmeta.png?w=2500&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=f1fd4e03dc028dc161a62729f02f2626 2500w" />

#### Acceder a la configuración de WhatsApp

En la sección de configuración, encontrarás el botón para iniciar la integración:

<img src="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/whatsapp-config.png?fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=a2113e85ef3859de5e7379fa43d1fdc1" alt="Configuración de WhatsApp" data-og-width="1471" width="1471" data-og-height="996" height="996" data-path="images/notmeta_whastapp_integration/whatsapp-config.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/whatsapp-config.png?w=280&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=3c00ddbb4ca6456aede9de6de352643c 280w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/whatsapp-config.png?w=560&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=cb46b05a2f3dc2a9191e66b95c83987b 560w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/whatsapp-config.png?w=840&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=ffd2c55c3d151e20644574421924efbd 840w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/whatsapp-config.png?w=1100&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=47cc1cda756ac9504f8c0278ea01fc62 1100w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/whatsapp-config.png?w=1650&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=51e45c7edc09f76e056203adacdcbbbf 1650w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/whatsapp-config.png?w=2500&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=da6d2bdbccbe002b63a0914d7457c20e 2500w" />

## Proceso de Integración Paso a Paso

NotMeta utiliza el flujo de **Embedded Signup de Meta** que simplifica la configuración y te permite activar el **modo coexistencia** para usar el mismo número tanto en la API como en la app oficial de WhatsApp Business.

### Requisitos previos

Antes de comenzar, asegúrate de que tu número cumpla con estos requisitos:

* ✅ **Debe poder recibir SMS o llamadas** para verificación
* ✅ **Debe estar registrado en la app oficial de WhatsApp Business**
* ✅ **No puede estar activo en otra cuenta de WhatsApp** simultáneamente
* ✅ **Formato internacional E.164** con código de país (ej: +5491123456789)
* ⚠️ **Los números VoIP o virtuales** pueden fallar en la verificación

<Warning>
  **Importante**: Ten tu celular con la app de WhatsApp Business a mano durante todo el proceso de configuración.
</Warning>

### Paso 1: Iniciar la integración

Haz clic en **"Iniciar Integración"** para comenzar el proceso.

<img src="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/1-step.jpeg?fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=7da4f09ca0402bdd98c0444cfe0b5f03" alt="Paso 1 - Iniciar integración" data-og-width="1280" width="1280" data-og-height="1002" height="1002" data-path="images/notmeta_whastapp_integration/1-step.jpeg" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/1-step.jpeg?w=280&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=2f409f3127af2a7f9291fedf3085a676 280w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/1-step.jpeg?w=560&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=2988756c57bc800d9ccd74f8fa49fcb2 560w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/1-step.jpeg?w=840&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=49004c5efb72e439ee6a631547cf7cba 840w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/1-step.jpeg?w=1100&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=64d517000b0376fa7f346600e2fd5546 1100w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/1-step.jpeg?w=1650&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=16ac48bff18a456fe6a936728c9d60df 1650w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/1-step.jpeg?w=2500&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=3f3524e18d1f559262c347f41c2c2443 2500w" />

### Paso 2: Autorización de Facebook

Se abrirá el modal de Facebook para iniciar la integración. Debes acceder a la cuenta de Facebook que tendrá el portafolio comercial de Facebook.

<img src="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/2-step.png?fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=39717ea7930e2c2d93a4fe930a366c86" alt="Paso 2 - Modal de Facebook" data-og-width="1391" width="1391" data-og-height="1153" height="1153" data-path="images/notmeta_whastapp_integration/2-step.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/2-step.png?w=280&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=e2d36b9f512a7bf01f31569d8fd92462 280w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/2-step.png?w=560&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=831d2381c10f4ef12810889403fabff2 560w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/2-step.png?w=840&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=6e4c667bcf95074210a97759259f9ab7 840w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/2-step.png?w=1100&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=69f267e229e091bcb7ad8e23938be7e0 1100w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/2-step.png?w=1650&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=f20ed56d012c2e2811af8b695aec8358 1650w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/2-step.png?w=2500&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=01580ef10c774024e72c298428c744de 2500w" />

### Paso 3: Seleccionar portafolio comercial

Selecciona el portafolio comercial a usar. Si no tienes uno, puedes crearlo desde aquí mismo con la opción desde el selector de portafolio comercial.

<img src="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/3-step.jpeg?fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=79b583d15dda6d27bc8c261f0c125125" alt="Paso 3 - Selección de portafolio" data-og-width="1280" width="1280" data-og-height="1016" height="1016" data-path="images/notmeta_whastapp_integration/3-step.jpeg" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/3-step.jpeg?w=280&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=61eebb2b5c5100dcd2e0f6f051c27ebd 280w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/3-step.jpeg?w=560&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=392e0463758ca5623b755c7d1a451d05 560w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/3-step.jpeg?w=840&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=2a4204ba3ac4e74ca1c8ac044f05b245 840w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/3-step.jpeg?w=1100&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=f65b34132a6764e455005745324ae625 1100w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/3-step.jpeg?w=1650&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=49485df522f4cace87683d2e915eff41 1650w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/3-step.jpeg?w=2500&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=188aae52eb2120041f17106b942c1a90 2500w" />

### Paso 4: Conectar tu número

Conecta tu número configurado en la app de WhatsApp Business (opción recomendada) para usar coexistencia. Esto te permitirá compartir tu número de forma muy fácil sin perder el acceso a él desde la app. Los mensajes son sincronizados automáticamente por NotMeta.

O comienza con un nuevo número y sigue los pasos que el proceso de Meta Facebook te indique. Siempre ten a mano tu teléfono con el número ya que Facebook solicita métodos de verificación como envío de mensaje, llamadas, escaneo de código QR, etc.

<img src="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/4-step.png?fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=75a9c992fd2d387cd02bb6d68b92e6cb" alt="Paso 4 - Conexión del número" data-og-width="1355" width="1355" data-og-height="1052" height="1052" data-path="images/notmeta_whastapp_integration/4-step.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/4-step.png?w=280&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=5a38fcb054e5cadec918065fefaaf05e 280w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/4-step.png?w=560&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=bea9ce9ee07a43a7946854ecebfea8f6 560w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/4-step.png?w=840&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=66b6f20393191ff085df40deea3ecebf 840w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/4-step.png?w=1100&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=454d8e8ee38851265c06d32302a7c821 1100w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/4-step.png?w=1650&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=60f8c940a190ad6c0b5a05fdead617ff 1650w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/4-step.png?w=2500&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=633f05f0c292b010dad9f98bbae469bb 2500w" />

### Paso 5: Configurar el número

Ingresa el número a configurar y presiona siguiente. Sigue las instrucciones que aparezcan en pantalla.

<img src="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/5-step.png?fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=330f57f9d58196d5a8be3495bcd76f13" alt="Paso 5 - Configuración del número" data-og-width="1380" width="1380" data-og-height="1044" height="1044" data-path="images/notmeta_whastapp_integration/5-step.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/5-step.png?w=280&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=270b835de4c68429e08b62b094244c8b 280w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/5-step.png?w=560&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=e526266ec76a0abddfed386c8a74dbbf 560w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/5-step.png?w=840&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=cee88354b03fc3c6e4a51383cb357d7b 840w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/5-step.png?w=1100&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=37ad9cae5bfba3c77bee387e5fd42eed 1100w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/5-step.png?w=1650&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=644da33e6a9d682c85280bbbfd56e49a 1650w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/5-step.png?w=2500&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=c2209ff067d167e95d35327636c1f54f 2500w" />

### Paso 6: Confirmar la integración

Revisa todos los datos y confirma la integración para completar el proceso.

<img src="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/6-step.png?fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=b8e4cd180395aaa2750a71dfbc4a5e57" alt="Paso 6 - Confirmación" data-og-width="1361" width="1361" data-og-height="1055" height="1055" data-path="images/notmeta_whastapp_integration/6-step.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/6-step.png?w=280&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=0a0347888e311dd73affa5da91a04d84 280w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/6-step.png?w=560&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=8d10e5aac26e58b2a8cfd31d724491e0 560w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/6-step.png?w=840&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=5cdbd1009f34dcbe4a2d5ce8c1ef54b2 840w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/6-step.png?w=1100&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=0bc77f336b2c2fec70ce3bf549434a18 1100w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/6-step.png?w=1650&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=44db9d5e3442a9187a09ff8c06d306eb 1650w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/6-step.png?w=2500&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=ca66a0a6483bb5cd586e0034eb5c17e3 2500w" />

### Paso 7: Integración completada

El modal se cerrará y recibirás un mensaje de confirmación por parte de NotMeta en la interfaz. Podrás ver tu número de teléfono configurado debajo del botón de integración. Al costado hay un botón para probar la integración, púlsalo y deberías recibir un mensaje de éxito. Este botón siempre es útil para verificar el estado de tu integración.

<img src="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/7-step.jpeg?fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=97116f216650548c2c59590a7f280b54" alt="Paso 7 - Integración completada" data-og-width="1280" width="1280" data-og-height="355" height="355" data-path="images/notmeta_whastapp_integration/7-step.jpeg" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/7-step.jpeg?w=280&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=5e25dd679044893a8cb8c5560aec7adb 280w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/7-step.jpeg?w=560&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=ca0f7d3fb99faf1118943af45eb8239e 560w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/7-step.jpeg?w=840&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=24a49937409f923cf4f516ccc74857c3 840w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/7-step.jpeg?w=1100&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=7b4c6ccc0ab9d3e0702eb2448a658cd7 1100w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/7-step.jpeg?w=1650&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=1d907531a46de8b32873fb1ec62795a2 1650w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/notmeta_whastapp_integration/7-step.jpeg?w=2500&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=bc31f3048999f79a06ccee669c4884fd 2500w" />

### Modo Coexistencia (Recomendado)

**Activa el modo coexistencia** para usar el mismo número tanto en la API como en la app de WhatsApp Business. Esto facilita la integración, aunque algunas funciones de la app pueden quedar limitadas.

**Beneficios del modo coexistencia:**

* ✅ Mantienes acceso al número desde la app oficial
* ✅ Sincronización automática de mensajes
* ✅ Transición suave sin interrupciones
* ✅ Fácil gestión desde ambas interfaces

### Métodos de verificación de Meta

Durante el proceso, Meta puede solicitar diferentes métodos de verificación:

* 📱 **SMS**: Recibirás un código por mensaje de texto
* 📞 **Llamada**: Meta te llamará con un código de verificación
* 📷 **Código QR**: Escanea un código QR con tu dispositivo
* 🔐 **Verificación en dos pasos**: Si tienes activada esta función

### Notas importantes

* El proceso puede variar ligeramente dependiendo de la opción que elijas
* Este proceso en el modal o popup es realizado 100% por Meta y cumple con todas sus especificaciones de seguridad
* Mantén tu dispositivo encendido y con conexión a internet durante todo el proceso
* Si encuentras algún problema, puedes reiniciar el proceso desde la configuración

## ¿Qué sucede después de la configuración?

Una vez completada la integración con Meta, el sistema podrá:

* ✅ **Enviar mensajes** utilizando el nombre del número de teléfono configurado
* ✅ **Recibir mensajes** de clientes en tiempo real
* ✅ **Gestionar conversaciones** desde la interfaz de NotMeta
* ✅ **Mantener acceso al número** desde la app de WhatsApp Business (modo coexistencia)

## Prueba tu integración

Una vez configurado, puedes probar tu integración:

1. **Usa el botón de prueba** en la configuración
2. **Envía un mensaje de prueba** a tu número
3. **Verifica que recibas** la confirmación de éxito
4. **Revisa el estado** de tu integración en cualquier momento

## Próximos pasos

<Columns cols={2}>
  <Card title="Gestión de Conversaciones" icon="comments" href="/users/managing-conversations">
    Aprende a gestionar conversaciones de manera eficiente
  </Card>

  <Card title="Colaboración en Equipo" icon="users" href="/users/team-collaboration">
    Maximiza la productividad de tu equipo
  </Card>
</Columns>

¿Necesitas ayuda? Contáctanos en [contact@damascuss.io](mailto:contact@damascuss.io)


# Introducción a NotMeta
Source: https://docs.damascuss.io/users/introduction

Conoce cómo NotMeta transforma la gestión de WhatsApp Business en una experiencia colaborativa

## ¿Qué es NotMeta?

NotMeta es una plataforma completa que permite que múltiples empleados gestionen el mismo número de WhatsApp Business simultáneamente. Con una interfaz familiar similar a WhatsApp, tu equipo puede adoptar la plataforma inmediatamente sin curva de aprendizaje.

## Características principales

### Gestión Multi-Usuario

Permite que múltiples empleados gestionen el mismo número de WhatsApp Business simultáneamente. Distribuye la carga de trabajo y mejora la eficiencia del equipo.

### Interfaz Familiar

Interfaz similar a WhatsApp que tu equipo ya conoce. Sin curva de aprendizaje, adopción inmediata y productividad desde el primer día.

### Análisis y Reportes

Métricas detalladas de conversaciones, tiempos de respuesta y rendimiento del equipo.

### Descarga y Análisis

Descarga tus conversaciones, obtén resúmenes e insights de contactos.

### Seguridad Empresarial

Cumple con los estándares de seguridad de WhatsApp Business API y protege los datos de tus clientes.

### Integración Rápida

Configura tu número de WhatsApp Business en minutos y comienza a gestionar conversaciones. Proceso de onboarding simplificado para que tu equipo esté operativo en tiempo récord.

## ¿Por qué elegir NotMeta?

Mantener las conversaciones de WhatsApp en un solo teléfono genera problemas críticos para tu negocio:

* **Pérdida de información crítica**: No puedes analizar automáticamente lo que sucede con tus clientes
* **Gestión de clientes desconocida**: No sabes cómo se está gestionando la atención al cliente
* **Tiempo de respuesta no medible**: No puedes medir ni mejorar el tiempo de respuesta promedio
* **Limitación de escalabilidad**: Solo una persona puede usar el mismo teléfono a la vez

### NotMeta resuelve todos estos problemas:

* ✅ Análisis automático completo
* ✅ Historial completo de conversaciones
* ✅ Métricas de tiempo de respuesta
* ✅ Escalabilidad ilimitada
* ✅ Asignación automática de chats
* ✅ Reportes y análisis detallados
* ✅ Centraliza todas las conversaciones
* ✅ Soporte técnico especializado

## Próximos pasos

<Card title="Comenzar con NotMeta" icon="rocket" href="/users/getting-started" horizontal>
  Configura tu cuenta y comienza a gestionar WhatsApp Business con tu equipo.
</Card>


# Integra a tu equipo
Source: https://docs.damascuss.io/users/team-collaboration

Aprende a gestionar usuarios y configurar roles en tu equipo de NotMeta

## Gestión de usuarios en NotMeta

NotMeta te permite gestionar tu equipo de trabajo asignando diferentes roles y permisos según las necesidades de tu organización. Con esta funcionalidad podrás agregar nuevos usuarios y definir qué acciones pueden realizar en la plataforma.

## Acceso al panel de administración

Para gestionar usuarios, debes acceder a la sección **Admin** de tu panel de NotMeta. Esta sección te permite configurar todos los aspectos administrativos de tu cuenta.

<img src="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/home.png?fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=8ab605b3f59b6420099106c4b459cfa7" alt="Panel de administración de NotMeta" data-og-width="1482" width="1482" data-og-height="867" height="867" data-path="images/team_managment/home.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/home.png?w=280&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=735ecf4252ddc8a7dc5f98a4f1ac07f7 280w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/home.png?w=560&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=e8623c8fe2fc05c86ce4b046e1ac38fc 560w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/home.png?w=840&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=615cc0ff4744b02f2c464bccf41d3cfe 840w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/home.png?w=1100&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=0ce3c1c49d103946304176eacf7882b0 1100w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/home.png?w=1650&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=1be47716b9287bc0d28ef4be2880a8aa 1650w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/home.png?w=2500&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=9deb35059ce073435faf638b80f86909 2500w" />

Como puedes ver en la imagen, el panel de administración es el lugar donde podrás gestionar usuarios, configurar integraciones y editar la información de tu negocio.

## Agregar un nuevo usuario

Para agregar un nuevo usuario a tu equipo, sigue estos pasos:

1. **Presiona el botón "Agregar usuario"** ubicado en la esquina superior derecha del panel de administración
2. **Se abrirá un modal** como el que se muestra en la siguiente imagen

<img src="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/create-user.png?fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=097ddd9a5744c46b5fd51f4221280879" alt="Modal para crear nuevo usuario" data-og-width="1426" width="1426" data-og-height="973" height="973" data-path="images/team_managment/create-user.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/create-user.png?w=280&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=8ad0453acd36cdb4fc8fc59be15936e7 280w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/create-user.png?w=560&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=d1858be9ca1916ed4fd19bea2eb0eefb 560w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/create-user.png?w=840&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=b52cf8eb77d0069f090903784774da7c 840w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/create-user.png?w=1100&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=0fda90d700df795724a4fb446b9de8e3 1100w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/create-user.png?w=1650&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=671b7c6c34ebe464fb5840df89f91334 1650w, https://mintcdn.com/damascuss/J2Ej2i-T5MsjkA-3/images/team_managment/create-user.png?w=2500&fit=max&auto=format&n=J2Ej2i-T5MsjkA-3&q=85&s=52f55b4eb905ce7cadf9c2aa03018a2b 2500w" />

3. **Completa los datos del usuario:**
   * **Correo electrónico**: Ingresa el email del usuario
   * **Datos básicos**: Llena la información personal requerida
   * **Rol**: Selecciona el tipo de usuario (Admin o Agente)

Una vez completados todos los campos, el usuario recibirá un correo electrónico informativo sobre su nuevo acceso a la plataforma.

> **Importante**: Este correo es únicamente informativo y no contiene la contraseña. La clave de acceso debe ser compartida directamente por el administrador y se recomienda que sea cambiada en el primer inicio de sesión. El correo sirve para verificar que la dirección ingresada es auténtica y será utilizada para notificaciones, recuperación de contraseña y otras comunicaciones del sistema.

## Roles del sistema

NotMeta maneja dos tipos de roles principales que determinan qué acciones puede realizar cada usuario:

### Administrador (Admin)

Los administradores tienen acceso completo al sistema y pueden:

* **Gestionar usuarios**: Agregar, editar y eliminar usuarios del equipo
* **Configurar integraciones**: Conectar números de WhatsApp y configurar webhooks
* **Editar información del negocio**: Modificar datos de la empresa y configuraciones generales
* **Acceso a reportes avanzados**: Ver estadísticas completas y métricas del sistema
* **Configuración de permisos**: Definir qué pueden hacer otros usuarios

### Agente

Los agentes son usuarios con permisos limitados, ideales para empleados que se encargan de la atención al cliente:

* **Gestión de contactos**: Crear, editar y organizar la base de contactos
* **Chat con clientes**: Responder conversaciones de WhatsApp asignadas
* **Acceso a plantillas**: Usar mensajes predefinidos para respuestas rápidas
* **Reportes personales**: Ver su propio rendimiento y estadísticas
* **Sin acceso administrativo**: No pueden modificar configuraciones del sistema

## Mejores prácticas

### Para administradores

* Asigna el rol de agente a empleados que solo necesiten atender clientes
* Mantén pocos administradores para mayor seguridad
* Revisa regularmente los permisos de los usuarios

### Para agentes

* Usa las plantillas disponibles para respuestas consistentes
* Mantén actualizada la información de los contactos
* Comunica cualquier problema técnico a los administradores

## Solución de problemas

### Usuario no recibe el correo informativo

* Verifica que el correo electrónico sea correcto
* Revisa la carpeta de spam del usuario
* Confirma que el usuario no tenga ya una cuenta activa
* Recuerda que el correo es solo informativo y no contiene la contraseña

### Problemas de permisos

* Los agentes no pueden acceder a funciones administrativas
* Si un usuario necesita más permisos, contacta a un administrador
* Los administradores pueden modificar roles en cualquier momento

### Gestión de acceso

* Los administradores pueden desactivar usuarios temporalmente
* Es posible cambiar el rol de un usuario existente
* Los usuarios pueden ser eliminados del sistema si es necesario