# Aptabase MCP MCP

> send_event sends structured telemetry data, custom app events, and system metadata directly to Aptabase. It lets your AI agent track how users interact with mobile or desktop apps, capturing everything from button clicks to purchase completions using a privacy-first approach.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** telemetry, mobile-analytics, event-tracking, privacy-first, app-monitoring

## Description

Need to know if the new checkout button actually gets clicked? This MCP connects your app's behavior data to Aptabase. Instead of building out complex analytics dashboards and manually checking logs, you talk to your agent. You can ask it to track specific actions—like when a user starts using an app or when they hit 'submit.' It sends everything structured: the event name, which OS version was used, and any custom details, like what subscription plan they were viewing.

This capability means you verify product performance without ever touching the SDK. You can simulate complex user journeys—tracking a purchase completion followed by an account update—all through conversation. Since Aptabase is built with privacy in mind, it's a solid alternative to common tracking services. When your agent connects this MCP via Vinkius, you get immediate access to reliable, structured performance data that tells you exactly what users are doing.

## Tools

### send_event
Processes an app usage event by sending structured data, including custom properties, to Aptabase.

## Prompt Examples

**Prompt:** 
```
Send an 'app_launch' event for my iOS app version 1.0.1.
```

**Response:** 
```
I've successfully sent the 'app_launch' event to Aptabase for iOS 17.0 (en-US) using version 1.0.1 of your application.
```

**Prompt:** 
```
Track a 'purchase_completed' event with properties for 'plan: pro' and 'amount: 19.99'.
```

**Response:** 
```
The 'purchase_completed' event has been dispatched with your custom properties (plan: pro, amount: 19.99) to your Aptabase project.
```

**Prompt:** 
```
Log a telemetry event for a Windows desktop app version 2.4.0 named 'sync_started'.
```

**Response:** 
```
I've recorded the 'sync_started' event for Windows 11 (app version 2.4.0) in your Aptabase analytics dashboard.
```

## Capabilities

### Log user actions
Send custom events for specific user interactions, such as app launches or feature usage.

### Track business metrics
Capture structured data points like purchase amounts or plan names when a transaction completes.

### Include system details
Automatically attach device and software information (like OS version or app build) to every event sent.

## Use Cases

### Investigating a drop in sign-ups
A Product Manager notices conversion rates dropped after the last update. They prompt their agent: 'Send an event for app_started, but only if the system metadata shows Android 12.' This quickly isolates whether the problem is specific to one OS version.

### Validating a new subscription feature
A Developer adds a premium tier. They use the agent to run multiple `send_event` calls, simulating 'purchase_completed' for various plan names and amounts (e.g., 'premium: $9.99'). This confirms the event structure handles all expected variations.

### Checking desktop app reliability
A QA Engineer needs to ensure data logging works on a Windows machine. They ask the agent to log an event named 'sync_started' specifically for the current application version and OS build, confirming system metadata is correct.

### Mapping user journey through onboarding
A PM wants to see if users are skipping crucial steps. They instruct their agent to track a sequence of events—`app_started`, followed by `button_clicked: tutorial`, and finally `feature_viewed: dashboard`. This maps the actual flow.

## Benefits

- Verify Purchase Flows: Instead of just guessing, you can track exact events like `purchase_completed` and include properties for the plan name or dollar amount every time.
- Test Across Devices: You capture detailed system metadata. This means you know if an event happened on iOS 17 versus Windows 11, giving precise segmentation data.
- Fast Development Cycles: Developers can test telemetry payloads immediately through conversation; no manual SDK integration is required just to validate a trigger.
- Privacy-First Data: You collect the necessary behavioral metrics without relying on services that compromise user trust. Aptabase keeps your data secure.
- Granular Behavior Tracking: By attaching flat JSON objects, you can capture deep user behavior and business metrics far beyond simple clicks.

## How It Works

The bottom line is, your AI client takes raw instructions about app behavior and converts them into structured analytics reports for you.

1. First, subscribe to this MCP and enter your unique Aptabase App Key.
2. Next, prompt your AI client with the specific data you want tracked (e.g., 'Send a purchase event for $29.99 on iOS').
3. The agent formats the payload and sends it; you'll get confirmation that the telemetry data was successfully recorded in Aptabase.

## Frequently Asked Questions

**How do I use the send_event tool with different device types?**
You include the specific OS name and version number directly in your prompt when calling `send_event`. This ensures every recorded event is properly segmented by device type.

**Does send_event only track basic clicks?**
No. You can attach detailed, custom JSON properties to any event. This lets you track complex metrics like 'subscription plan: pro' and 'amount: 19.99,' not just simple button clicks.

**What kind of data is best for send_event?**
It works best with user journey events—things that happen sequentially, like app start -> view product -> add to cart -> purchase_completed. Use the tool to map these flows.

**Is sending an event asynchronous using send_event?**
Yes, `send_event` processes events asynchronously. You get confirmation that the data was received by Aptabase, but the actual processing happens in the background, keeping your workflow fast.

**What credentials do I need to set up `send_event` for my project?**
You must provide your Aptabase App Key. This key authenticates your data source and ensures the event payload gets routed correctly to your specific analytics project.

**Can I send complex, nested JSON data using `send_event`?**
Yes, you can include custom properties as flat JSON objects. This structure lets you capture granular user behavior and business metrics that go beyond simple key-value pairs.

**What happens if `send_event` fails because of a temporary network interruption?**
The tool is built for asynchronous processing, which helps manage temporary failures gracefully. This design minimizes the chance of losing critical telemetry data during an interrupted call.

**Does `send_event` automatically include system metadata like OS version and locale?**
Yes, you pass detailed system information such as the OS name, app version, and locale. This is vital for accurate segmentation when reviewing your analytics data.

**Can I send custom metadata with my events?**
Yes! Use the `props` field in the `send_event` tool to provide a JSON object with key-value pairs representing your custom properties.

**Is it possible to track the specific OS version?**
Absolutely. The `send_event` tool requires `osName` and `osVersion` parameters to ensure your telemetry is correctly segmented in the Aptabase dashboard.

**Can I use this for self-hosted Aptabase instances?**
Yes, you can optionally provide a `baseUrl` in the configuration to point the MCP server to your own self-hosted Aptabase instance.