API Documentation

Server Information

Returns basic information about the MCP server.

Response

API Documentation

Returns detailed information about available methods, tools, and Windsurf configuration.

Response

List Available Resources

Returns a list of resources available through the MCP server.

Response

Get App Details

Returns detailed information about a specific app.

Response

Query Events

Allows querying events with various filters.

Parameters

• app_id - Filter by app ID
• event_name - Filter by event name
• user_id - Filter by user ID
• limit - Maximum number of results (default: 100, max: 1000)
• offset - Pagination offset (default: 0)

Response

Get App Versions

Returns version release history for an app. Use this to analyze how new releases impact performance and engagement.

Response

Get App Versions Tool

MCP tool for AI assistants to fetch version history with optional date filtering.

Parameters

• app_id (required) - App ID to retrieve versions for
• start_date (optional) - Filter versions released after this date (ISO 8601)
• end_date (optional) - Filter versions released before this date (ISO 8601)

Example Prompt

The AI assistant will use get_app_versions to find the release date, then query events before and after to compare metrics.

Create Audience Tool

Create an audience from a natural language description with AI-powered SQL generation. The tool uses pattern matching, vector similarity, and LLM generation to convert descriptions into SQL queries.

Parameters

• app_id (optional) - Target app (auto-selected if org has 1 app)
• name (required) - Audience name
• description (required) - Natural language description used as AI prompt

Example Prompt

Response

Create Push Campaign Tool

Create a push notification campaign with optional AI-generated message, audience, and trigger event detection. Supports scheduled, recurring, slipping_away, and trigger-based campaigns.

Parameters

• app_id (optional) - Target app (auto-selected if org has 1 app)
• name (required) - Campaign identifier
• title (required) - Push notification title
• message (conditional) - Static message (if no prompt)
• prompt (conditional) - AI prompt for message generation
• audience_id (optional) - Existing audience to target
• audience_prompt (optional) - Create audience from this prompt
• schedule_type (required) - scheduled, recurring, slipping_away, or trigger
• scheduled_at (conditional) - ISO 8601 datetime for scheduled
• trigger_event_name (conditional) - Exact event name for trigger campaigns
• trigger_event_prompt (conditional) - Natural language description - AI matches to tracked events
• action_url (optional) - URL to open on tap

Example Prompt - Scheduled

Example Prompt - Trigger

Response

List Push Campaigns Tool

List push notification campaigns for an app with optional status filtering and delivery stats.

Parameters

• app_id (optional) - Target app (auto-selected if org has 1 app)
• status (optional) - Filter by: scheduled, live, paused, sent
• limit (optional) - Max results (default: 50)

Example Prompt

List Event Dictionary Tool

List event dictionary entries for an app with optional filtering by archived status, undefined events, or search terms.

Parameters

• app_id (required) - Target app ID
• include_archived (optional) - Include archived events (default: false)
• only_undefined (optional) - Show only events without definitions (default: false)
• search (optional) - Search event names (case-insensitive partial match)
• limit (optional) - Max results (default: 100, max: 500)

Example Prompts

Update Event Definition Tool

Update the definition for a single event by ID or name. Can also be used to clear definitions or archive events.

Parameters

• app_id (required) - Target app ID
• event_id (optional) - Event dictionary ID (use this OR event_name)
• event_name (optional) - Event name to update (use this OR event_id)
• definition (required) - New definition text (empty string to clear)

Example Prompts

Auto-Define Events Tool

AI-powered batch definition generation for events. Analyzes event names, usage patterns, and sample data to generate meaningful definitions.

Parameters

• app_id (required) - Target app ID
• mode (required) - "empty_only" or "overwrite_all"
• dry_run (optional) - Preview changes without saving (default: false)
• event_names (optional) - Array of specific event names to process

Example Prompts

Response

Implement an AI coding assistant that can access your app's event data to suggest code improvements or debug issues.

Setup Steps:

1. Enable MCP in your organization settings
2. Generate a dedicated MCP API key for your coding assistant
3. Implement the following integration code in your development environment

Example Implementation:

# Python example for VSCode extension or Jupyter notebook
import os
from openai import OpenAI
import requests

class AppizerDevAgent:
    def __init__(self, mcp_api_key, openai_api_key):
        self.mcp_api_key = mcp_api_key
        self.mcp_base_url = "https://api.appizer.com/mcp"
        self.mcp_headers = {"X-MCP-API-Key": mcp_api_key}
        self.client = OpenAI(api_key=openai_api_key)
    
    def get_event_data(self, app_id, event_name=None, limit=10):
        """Fetch recent events from the app"""
        params = {"app_id": app_id, "limit": limit}
        if event_name:
            params["event_name"] = event_name
            
        response = requests.get(
            f"{self.mcp_base_url}/events",
            headers=self.mcp_headers,
            params=params
        )
        return response.json()
    
    def analyze_code_with_context(self, code_snippet, issue_description):
        """Analyze code with context from app events"""
        # Get event data for context
        events_data = self.get_event_data(app_id="YOUR_APP_ID")
        
        # Create prompt with code and event context
        prompt = f"""
        Analyze this code snippet:
        ```
        {code_snippet}
        ```
        
        Issue description: {issue_description}
        
        Recent app events for context:
        {events_data}
        
        Please provide suggestions to fix the issue based on the code and event data.
        """
        
        # Get AI analysis
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "You are a coding assistant with access to app event data."},
                {"role": "user", "content": prompt}
            ]
        )
        
        return {
            "visualizations": [],
            "insights": response.choices[0].message.content
        }

# Usage
agent = AppizerDevAgent(
    mcp_api_key="YOUR_MCP_API_KEY",
    openai_api_key="YOUR_OPENAI_API_KEY"
)

# Example analysis
code = """
function processUserPurchase(userId, itemId) {
    // Implementation with potential issues
    const user = getUser(userId);
    const item = getItem(itemId);
    
    if (user.credits >= item.price) {
        user.credits -= item.price;
        user.items.push(item);
        trackEvent('purchase', { userId, itemId });
    }
}
"""

analysis = agent.analyze_code_with_context(
    code,
    "Users report purchases sometimes fail even with sufficient credits"
)
print(analysis["insights"])
                                

// Node.js example for VSCode extension or development environment
const axios = require('axios');
const { OpenAI } = require('openai');

class AppizerDevAgent {
  constructor(mcpApiKey, openaiApiKey) {
    this.mcpApiKey = mcpApiKey;
    this.mcpBaseUrl = 'https://api.appizer.com/mcp';
    this.openai = new OpenAI({ apiKey: openaiApiKey });
  }

  async getEventData(appId, eventName = null, limit = 10) {
    // Fetch recent events from the app
    const params = { app_id: appId, limit };
    if (eventName) params.event_name = eventName;
    
    try {
      const response = await axios.get(`${this.mcpBaseUrl}/events`, {
        headers: { 'X-MCP-API-Key': this.mcpApiKey },
        params
      });
      return response.data;
    } catch (error) {
      console.error('Error fetching event data:', error);
      return { events: [] };
    }
  }

  async analyzeCodeWithContext(codeSnippet, issueDescription) {
    // Get event data for context
    const eventsData = await this.getEventData('YOUR_APP_ID');
    
    // Create prompt with code and event context
    const prompt = `
      Analyze this code snippet:
      \`\`\`
      ${codeSnippet}
      \`\`\`
      
      Issue description: ${issueDescription}
      
      Recent app events for context:
      ${JSON.stringify(eventsData, null, 2)}
      
      Please provide suggestions to fix the issue based on the code and event data.
    `;
    
    // Get AI analysis
    const completion = await this.openai.chat.completions.create({
      model: "gpt-4",
      messages: [
        { role: "system", content: "You are a coding assistant with access to app event data." },
        { role: "user", content: prompt }
      ]
    });
    
    return {
      visualizations: [],
      insights: completion.choices[0].message.content
    };
  }
}

// Usage
const agent = new AppizerDevAgent(
  'YOUR_MCP_API_KEY',
  'YOUR_OPENAI_API_KEY'
);

// Example analysis
const code = `
function processUserPurchase(userId, itemId) {
    // Implementation with potential issues
    const user = getUser(userId);
    const item = getItem(itemId);
    
    if (user.credits >= item.price) {
        user.credits -= item.price;
        user.items.push(item);
        trackEvent('purchase', { userId, itemId });
    }
}
`;

async function runAnalysis() {
  const analysis = await agent.analyzeCodeWithContext(
    code,
    "Users report purchases sometimes fail even with sufficient credits"
  );
  console.log(analysis.insights);
}

runAnalysis();
                                

Key Benefits:

• AI coding assistance with real-time app data context
• Debug issues with actual event data from your application
• Generate code suggestions based on user behavior patterns
• Automate repetitive development tasks with app-aware AI

Build a support chatbot that can access user data and event history to provide personalized assistance.

Example Implementation:

# Python example for a customer support chatbot
import requests
from openai import OpenAI

class AppizerSupportBot:
    def __init__(self, mcp_api_key, openai_api_key):
        self.mcp_api_key = mcp_api_key
        self.mcp_base_url = "https://api.appizer.com/mcp"
        self.mcp_headers = {"X-MCP-API-Key": mcp_api_key}
        self.client = OpenAI(api_key=openai_api_key)
    
    def get_user_data(self, user_id):
        """Fetch user profile data"""
        try:
            response = requests.get(
                f"{self.mcp_base_url}/users/{user_id}",
                headers=self.mcp_headers
            )
            return response.json()
        except Exception as e:
            print(f"Error fetching user data: {e}")
            return None
    
    def get_user_events(self, user_id, limit=10):
        """Fetch recent user activity"""
        try:
            response = requests.get(
                f"{self.mcp_base_url}/events",
                headers=self.mcp_headers,
                params={"user_id": user_id, "limit": limit}
            )
            return response.json().get("events", [])
        except Exception as e:
            print(f"Error fetching user events: {e}")
            return []
    
    def handle_support_query(self, user_id, query):
        """Generate personalized support response"""
        # Get user context
        user_data = self.get_user_data(user_id)
        user_events = self.get_user_events(user_id)
        
        # Create context-aware prompt
        system_prompt = f"""You are a helpful customer support assistant for our app.
        You have access to the following user data: {user_data}
        
        Recent user activity: {user_events}
        
        Based on this context, provide a helpful, personalized response."""
        
        # Generate AI response
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": query}
            ]
        )
        
        return response.choices[0].message.content

# Usage example
support_bot = AppizerSupportBot(
    mcp_api_key="YOUR_MCP_API_KEY",
    openai_api_key="YOUR_OPENAI_API_KEY"
)

# Example usage
response = support_bot.handle_support_query(
    "user_123", 
    "Why was I charged twice for my subscription?"
)
print(f"Response: {response}")
                                

// Node.js example for a customer support chatbot
const axios = require('axios');
const { OpenAI } = require('openai');

class AppizerSupportBot {
  constructor(mcpApiKey, openaiApiKey) {
    this.mcpApiKey = mcpApiKey;
    this.mcpBaseUrl = 'https://api.appizer.com/mcp';
    this.openai = new OpenAI({ apiKey: openaiApiKey });
  }

  async getUserData(userId) {
    try {
      const response = await axios.get(`${this.mcpBaseUrl}/users/${userId}`, {
        headers: { 'X-MCP-API-Key': this.mcpApiKey }
      });
      return response.data;
    } catch (error) {
      console.error('Error fetching user data:', error);
      return null;
    }
  }

  async getUserEvents(userId, limit = 10) {
    try {
      const response = await axios.get(`${this.mcpBaseUrl}/events`, {
        headers: { 'X-MCP-API-Key': this.mcpApiKey },
        params: { user_id: userId, limit }
      });
      return response.data.events;
    } catch (error) {
      console.error('Error fetching user events:', error);
      return [];
    }
  }

  async handleSupportQuery(userId, query) {
    // Get user context
    const userData = await this.getUserData(userId);
    const userEvents = await this.getUserEvents(userId);
    
    // Create context-aware prompt
    const systemPrompt = `You are a helpful customer support assistant for our app.
    You have access to the following user data: ${JSON.stringify(userData)}
    
    Recent user activity: ${JSON.stringify(userEvents)}
    
    Based on this context, provide a helpful, personalized response.`;
    
    // Generate AI response
    const completion = await this.openai.chat.completions.create({
      model: "gpt-4",
      messages: [
        { role: "system", content: systemPrompt },
        { role: "user", content: query }
      ]
    });
    
    return completion.choices[0].message.content;
  }
}

// Usage example
const supportBot = new AppizerSupportBot(
  'YOUR_MCP_API_KEY',
  'YOUR_OPENAI_API_KEY'
);

async function handleCustomerQuery(userId, query) {
  const response = await supportBot.handleSupportQuery(userId, query);
  console.log(`Response for user ${userId}: ${response}`);
  return response;
}

// Example usage
handleCustomerQuery('user_123', 'Why was I charged twice for my subscription?');
                                

Generate insights and visualizations from your app data using AI.

Example Implementation:

# Python example for data analysis with pandas and matplotlib
import os
import requests
import pandas as pd
import matplotlib.pyplot as plt
from openai import OpenAI

class AppizerAnalytics:
    def __init__(self, mcp_api_key, openai_api_key):
        self.mcp_api_key = mcp_api_key
        self.mcp_base_url = "https://api.appizer.com/mcp"
        self.mcp_headers = {"X-MCP-API-Key": mcp_api_key}
        self.client = OpenAI(api_key=openai_api_key)
    
    def get_event_data(self, app_id, event_name=None, days=30, limit=1000):
        """Fetch event data for analysis"""
        params = {"app_id": app_id, "limit": limit}
        if event_name:
            params["event_name"] = event_name
            
        response = requests.get(
            f"{self.mcp_base_url}/events",
            headers=self.mcp_headers,
            params=params
        )
        return response.json()["events"]
    
    def analyze_events(self, app_id, event_name):
        """Analyze specific event patterns"""
        # Get event data
        events = self.get_event_data(app_id, event_name)
        
        # Convert to DataFrame for analysis
        df = pd.DataFrame(events)
        
        # Extract timestamps and convert to datetime
        df['created_at'] = pd.to_datetime(df['created_at'])
        df['date'] = df['created_at'].dt.date
        
        # Group by date and count events
        daily_counts = df.groupby('date').size().reset_index(name='count')
        
        # Create visualization
        plt.figure(figsize=(10, 6))
        plt.plot(daily_counts['date'], daily_counts['count'])
        plt.title(f'{event_name} Events Over Time')
        plt.xlabel('Date')
        plt.ylabel('Event Count')
        plt.xticks(rotation=45)
        plt.tight_layout()
        
        # Save visualization
        viz_path = f"{event_name}_trend.png"
        plt.savefig(viz_path)
        
        # Generate AI insights
        prompt = f"""
        Analyze this event data for {event_name} events:
        {daily_counts.to_string()}
        
        Provide 3-5 key insights about user behavior patterns, anomalies, 
        and recommendations based on this data.
        """
        
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "You are a data analyst providing insights on app usage patterns."},
                {"role": "user", "content": prompt}
            ]
        )
        
        return {
            "visualization_path": viz_path,
            "insights": response.choices[0].message.content,
            "raw_data": daily_counts.to_dict()
        }

# Usage
analytics = AppizerAnalytics(
    mcp_api_key="YOUR_MCP_API_KEY",
    openai_api_key="YOUR_OPENAI_API_KEY"
)

# Example analysis
results = analytics.analyze_events("app_123", "purchase")
print(results["insights"])
                                

// Node.js example for data analysis and visualization
const axios = require('axios');
const { OpenAI } = require('openai');
const fs = require('fs');
const { ChartJSNodeCanvas } = require('chartjs-node-canvas');

class AppizerAnalytics {
  constructor(mcpApiKey, openaiApiKey) {
    this.mcpApiKey = mcpApiKey;
    this.mcpBaseUrl = 'https://api.appizer.com/mcp';
    this.openai = new OpenAI({ apiKey: openaiApiKey });
  }

  async getEventData(appId, eventName = null, days = 30, limit = 1000) {
    // Fetch event data for analysis
    const params = { app_id: appId, limit };
    if (eventName) params.event_name = eventName;
    
    try {
      const response = await axios.get(`${this.mcpBaseUrl}/events`, {
        headers: { 'X-MCP-API-Key': this.mcpApiKey },
        params
      });
      return response.data.events;
    } catch (error) {
      console.error('Error fetching event data:', error);
      return [];
    }
  }

  async analyzeEvents(appId, eventName) {
    // Get event data
    const events = await this.getEventData(appId, eventName);
    
    // Process data for analysis
    const eventsByDate = {};
    events.forEach(event => {
      const date = event.created_at.split('T')[0]; // Extract YYYY-MM-DD
      eventsByDate[date] = (eventsByDate[date] || 0) + 1;
    });
    
    // Convert to arrays for charting
    const dates = Object.keys(eventsByDate).sort();
    const counts = dates.map(date => eventsByDate[date]);
    
    // Create visualization using Chart.js
    const width = 800;
    const height = 500;
    const chartCallback = (ChartJS) => {
      // Optional: Global chart configuration
    };
    
    const chartJSNodeCanvas = new ChartJSNodeCanvas({ width, height, chartCallback });
    const configuration = {
      type: 'line',
      data: {
        labels: dates,
        datasets: [{
          label: `${eventName} Events Over Time`,
          data: counts,
          borderColor: 'rgb(75, 192, 192)',
          tension: 0.1
        }]
      },
      options: {
        scales: {
          y: { beginAtZero: true },
          x: { ticks: { maxRotation: 45 } }
        }
      }
    };
    
    // Generate chart image
    const image = await chartJSNodeCanvas.renderToBuffer(configuration);
    const vizPath = `${eventName}_trend.png`;
    fs.writeFileSync(vizPath, image);
    
    // Generate AI insights
    const dataForPrompt = dates.map((date, i) => `${date}: ${counts[i]}`).join('\n');
    const prompt = `
      Analyze this event data for ${eventName} events:
      ${dataForPrompt}
      
      Provide 3-5 key insights about user behavior patterns, anomalies,
      and recommendations based on this data.
    `;
    
    const completion = await this.openai.chat.completions.create({
      model: "gpt-4",
      messages: [
        { role: "system", content: "You are a data analyst providing insights on app usage patterns." },
        { role: "user", content: prompt }
      ]
    });
    
    return {
      visualization_path: vizPath,
      insights: completion.choices[0].message.content,
      raw_data: { dates, counts }
    };
  }
}

// Usage
const analytics = new AppizerAnalytics(
  'YOUR_MCP_API_KEY',
  'YOUR_OPENAI_API_KEY'
);

// Example analysis
async function runAnalysis() {
  const results = await analytics.analyzeEvents('app_123', 'purchase');
  console.log(results.insights);
}

runAnalysis();
                                

API Key Management:

• Create dedicated API keys for each integration
• Store keys in environment variables, never hardcode them
• Implement a key rotation schedule (e.g., quarterly)
• Set up access logging for all MCP API calls

Example .env File:

# Development environment
APPIZER_MCP_API_KEY=your_dev_mcp_key_here

APPIZER_MCP_BASE_URL=https://api.appizer.com/mcp

APPIZER_ORG_ID=your_org_id_here

# For production, use a different key with appropriate permissions
# APPIZER_MCP_API_KEY_PROD=your_prod_mcp_key_here

# For AI integrations
OPENAI_API_KEY=your_openai_key_here
                            

Monitoring MCP Usage:

// Node.js example for logging MCP API access
const winston = require('winston');
const axios = require('axios');

// Configure logger
const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  defaultMeta: { service: 'mcp-client' },
  transports: [
    new winston.transports.File({ filename: 'mcp-access.log' })
  ]
});

// Create axios instance with interceptors
const mcpClient = axios.create({
  baseURL: process.env.APPIZER_MCP_BASE_URL,
  headers: { 'X-MCP-API-Key': process.env.APPIZER_MCP_API_KEY }
});

// Log all requests
mcpClient.interceptors.request.use(request => {
  logger.info('MCP API Request', {
    method: request.method,
    url: request.url,
    params: request.params
  });
  return request;
});

// Log all responses
mcpClient.interceptors.response.use(
  response => {
    logger.info('MCP API Response', {
      status: response.status,
      data: response.data ? 'Data received' : 'No data'
    });
    return response;
  },
  error => {
    logger.error('MCP API Error', {
      status: error.response?.status,
      message: error.message
    });
    return Promise.reject(error);
  }
);

// Example usage
async function fetchApps() {
  try {
    const response = await mcpClient.get('/resources');
    return response.data;
  } catch (error) {
    console.error('Error fetching resources:', error);
    return null;
  }
}
                            

LangChain Integration

Example of integrating MCP with LangChain:

# Python example with LangChain
from langchain.tools import BaseTool
from langchain.agents import initialize_agent
from langchain.chat_models import ChatOpenAI
import requests

class AppizerMCPTool(BaseTool):
    name = "appizer_mcp"
    description = "Access Appizer data through MCP"
    
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.appizer.com/mcp"
        self.headers = {"X-MCP-API-Key": api_key}
    
    def _run(self, query):
        # Example: Get app resources
        response = requests.get(
            f"{self.base_url}/resources",
            headers=self.headers
        )
        return response.json()

# Initialize the tool and language model
mcp_tool = AppizerMCPTool(api_key="YOUR_MCP_API_KEY")
llm = ChatOpenAI(model="gpt-4")

# Use with an agent
agent = initialize_agent([mcp_tool], llm, agent="zero-shot-react-description")
result = agent.run("What apps are available in my Appizer account?")
                            

Code Editor Integration

Enable Appizer MCP in AI-powered code editors to enhance your development workflow. Different editors use different configuration formats:

Windsurf

Windsurf expects serverUrl in the configuration:

{
  "mcpServers": {
    "appizer": {
      "serverUrl": "https://app.appizer.com/mcp",
      "headers": {
        "X-MCP-API-Key": "YOUR_MCP_API_KEY"
      }
    }
  }
}

Cursor IDE

Cursor uses url and stores config in ~/.cursor/mcp_config.json:

{
  "mcpServers": {
    "appizer": {
      "url": "https://app.appizer.com/mcp",
      "headers": {
        "X-MCP-API-Key": "YOUR_MCP_API_KEY"
      }
    }
  }
}

Setup: Open Cursor Settings (Cmd/Ctrl + ,) → Search for "MCP" → Click "Edit Config" → Add the configuration above → Restart Cursor

Claude Desktop

Claude Desktop uses url and stores config in ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "appizer": {
      "url": "https://app.appizer.com/mcp",
      "headers": {
        "X-MCP-API-Key": "YOUR_MCP_API_KEY"
      }
    }
  }
}

Claude Code

Claude Code requires explicit transport specification for HTTP servers. You can configure it via CLI or JSON:

CLI Configuration (Recommended):

claude mcp add --transport http appizer https://app.appizer.com/mcp \
  --header "X-MCP-API-Key: YOUR_MCP_API_KEY"

JSON Configuration: Add to ~/.claude.json (user scope) or .mcp.json (project scope):

{
  "mcpServers": {
    "appizer": {
      "transport": "http",
      "url": "https://app.appizer.com/mcp",
      "headers": {
        "X-MCP-API-Key": "YOUR_MCP_API_KEY"
      }
    }
  }
}

Verify Connection: Run claude mcp list and claude mcp get appizer

Google Antigravity

Google Antigravity uses serverUrl and is configured via Extensions → Model Context Protocol:

{
  "mcpServers": {
    "appizer": {
      "serverUrl": "https://app.appizer.com/mcp",
      "headers": {
        "X-MCP-API-Key": "YOUR_MCP_API_KEY"
      }
    }
  }
}

Setup: Open Antigravity settings → Navigate to Extensions → Model Context Protocol → Add the configuration above → Restart Antigravity

SSE-based Editors

Some editors expect url instead of serverUrl:

{
  "mcpServers": {
    "appizer": {
      "url": "https://app.appizer.com/mcp",
      "headers": {
        "X-MCP-API-Key": "YOUR_MCP_API_KEY"
      }
    }
  }
}

Editor Features

• Access your Appizer resources directly from your editor
• Query events, users, and analytics data in real-time
• Generate code based on your Appizer data models
• Debug MCP integrations with inline suggestions
• Receive contextual documentation while coding