Aptabase MCP. Track app usage and performance from conversation.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Send an event. This tool sends custom telemetry and system events (like app launches or purchases) directly to Aptabase. Use it to track user behavior, test event triggers, or log system metadata from your AI agent.
It's a privacy-first way to monitor app usage across mobile and desktop platforms.
What your AI agents can do
Send event
Sends a custom event, including properties and system metadata, to Aptabase for tracking.
Send core events (e.g., app_launch, app_closed) to track when the user starts or stops using the application.
Send custom events for user interactions, like button clicks or form submissions, along with specific details.
Send purchase_completed events, including properties like the plan type and the monetary amount.
Attach system metadata—OS name, device version, locale—to ensure accurate data segmentation.
Attach arbitrary JSON properties to any event to log specific, granular user or business metrics.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Aptabase (Mobile Analytics) MCP Server: 1 Tool for Event Processing
The `send_event` tool lets you send structured telemetry and custom events to Aptabase, tracking app usage and performance across platforms.
019e3866send event
Sends a custom event, including properties and system metadata, to Aptabase for tracking.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Aptabase (Mobile Analytics), then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
Aptabase MCP Server - Track App Usage & Events
Your AI client uses the send_event tool to send custom telemetry and system events directly to Aptabase. It's a privacy-first way to monitor app usage across mobile and desktop platforms.
Log App Lifecycle Events
It sends core events like app_launch and app_closed to track when the user starts or stops using the application.
Track User Actions
It tracks user interactions, sending custom events for things like button clicks or form submissions. You can include specific details with these actions.
Record Purchases and Transactions
It sends purchase_completed events, logging details like the plan type and the monetary amount.
Include System Context
It attaches system metadata—OS name, device version, and locale—to keep your data accurate and segmented.
Capture Custom Business Data
It attaches arbitrary JSON properties to any event, letting you log specific, granular user or business metrics.
How Aptabase MCP Works
- 1 Subscribe to the Aptabase server and input your unique Aptabase App Key.
- 2 Your AI agent invokes the
send_eventtool, providing the event name, properties, and system metadata. - 3 The tool sends the telemetry data asynchronously to Aptabase, logging the event for later analysis.
The bottom line is, your AI agent sends structured event data to Aptabase without needing to know how Aptabase works internally.
Who Is Aptabase MCP For?
Product Managers, Mobile Developers, and QA Engineers. If you need to know how and why users are using your app—not just if they are—this is for you. It lets you verify complex analytics flows and test event triggers right from a conversation.
Simulates and verifies analytics events for new features by instructing the agent to track specific user paths (e.g., 'Send a purchase_completed event for the premium plan').
Quickly tests event triggers and telemetry payloads during development without having to manually write and integrate SDK code.
Automates the validation of analytics tracking across multiple OS versions and locales by directing the agent to log various system metadata.
What Changes When You Connect
- Track the full user journey. You can send custom events like
purchase_completedorbutton_clickedwith specific properties, giving you far more detail than simple session counts. - Test event logic instantly. Developers can verify event triggers and telemetry payloads for new features without manually implementing or running the full SDK.
- Segment data accurately. The tool captures detailed system metadata—OS name, version, and locale—so you can filter and analyze usage patterns by device or region.
- Maintain user trust. Aptabase is privacy-first, letting you collect necessary data without compromising user trust, which is key for modern apps.
- Verify complex flows. QA can simulate multi-step user flows (e.g., launch -> button click -> purchase) and confirm every event fires correctly.
- Log business metrics easily. Attach flat JSON objects to events. This lets you capture niche business metrics that don't fit into standard tracking fields.
Real-World Use Cases
Need to test a new premium feature flow.
A PM needs to verify the purchase tracking. They ask their agent to 'Track a purchase_completed event with properties for plan: pro and amount: 19.99.' The agent uses send_event and logs the event instantly to Aptabase, confirming the data structure before any code is written.
Debugging a broken app launch event.
A developer notices that app_started events aren't logging for new iOS versions. They ask their agent to 'Send an app_launch event for my iOS app version 1.0.1.' The agent uses send_event to test the payload and system context, confirming if the event structure is correct.
Analyzing desktop sync behavior.
A QA engineer wants to confirm telemetry logging for a Windows desktop app. They instruct the agent to 'Log a telemetry event for a Windows desktop app version 2.4.0 named sync_started.' The agent uses send_event to record the specific event and OS details in Aptabase.
Tracking a complex onboarding sequence.
A team needs to confirm a multi-step user flow. They ask the agent to sequentially send events: first, app_launch; then, button_clicked (with a property onboarding_step: 2); and finally, purchase_completed. This confirms the entire sequence works end-to-end.
The Tradeoffs
Writing boilerplate SDK code
A developer has to write, compile, and run a local script just to test if the button_clicked event fires correctly for a specific OS version. This is slow, brittle, and requires manual setup every time.
→
Instead, have your agent use send_event. You just tell your agent, 'Send a button_clicked event for macOS 14 (en-US).' The agent handles the payload and sends it directly, letting you test event logic instantly.
Relying on full dashboard rebuilds
When changing a business metric, the team waits days for the data pipeline to ingest and process the change, delaying validation and slowing down iteration cycles.
→
Use send_event to simulate the change immediately. You can tell your agent to 'Send a button_clicked event with properties for metric: conversion_button.' You get immediate feedback on the event's successful logging.
Manually segmenting test data
A tester wants to see how the app performs on Android vs. iOS. They must manually run two separate test suites and merge the resulting data streams.
→
Instruct your agent to send the event, making sure to include the system metadata. For example: 'Send an app_launch event for Android 13 (en-US) using version 1.0.1.' This logs the specific OS context in one go.
When It Fits, When It Doesn't
Use this if you need to verify, test, or simulate analytics events. You need to prove that a specific user action (like a purchase or a button click) generates the correct data payload and lands in Aptabase. This is ideal for developers and QA who need fast, non-invasive testing.
Don't use this if you need to consume the data itself (e.g., running reports, building dashboards). Use a dedicated data warehouse or BI tool for that. Also, don't use this if your system requires immediate, transactional consistency (ACID properties)—it's for event logging, not state management.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Aptabase. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 1 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Tracking user behavior shouldn't require writing and deploying SDKs.
Right now, testing an event flow means writing a small script. You have to include the OS detection, the app version, the custom properties, and the event name. Then, you have to compile it, run it, and wait for the data to show up in the analytics dashboard. It's slow, and you're always fighting deployment cycles.
With the Aptabase MCP Server, you just talk to your agent. You say, 'Log a `purchase_completed` event for the enterprise tier.' The agent runs the `send_event` tool, handles all the metadata, and logs the event immediately. You get the data without touching a single line of code.
Aptabase MCP Server: Log specific app events instantly.
Manual testing used to require checking dozens of tabs: one for the OS version, one for the app version, one for the event name, and several others for the properties. Everything was siloed and required multiple manual inputs to get a single clean record.
Now, the `send_event` tool handles it all. You pass one command to your agent, and it packages the event, the properties, and the system metadata into one payload. The data is clean, complete, and ready for analysis.
Common Questions About Aptabase MCP
How do I use the send_event tool with custom properties? +
You include the custom properties directly in your prompt. The tool accepts flat JSON objects, letting you log anything from 'plan' to 'amount' without altering the tool's code.
Does send_event track system metadata for all devices? +
Yes, the tool includes system metadata like OS name, version, and locale. This ensures your events are always tagged with the correct device context for accurate segmentation.
Is Aptabase better than Google Analytics for event tracking? +
Aptabase is an open-source, privacy-first alternative. It focuses on giving you granular control over the data and how it's collected, which is important for modern user trust.
What kind of events can I send using send_event? +
You can send any custom event, such as app_started, purchase_completed, or any unique event name specific to your app's business logic.
When using the send_event tool, what format should the custom properties take? +
Custom properties must be provided as flat JSON objects. You can attach these objects to any event payload to capture granular user behavior and business metrics.
How does the send_event tool handle data privacy and security? +
Aptabase is designed with privacy-first principles. The tool collects data without compromising user trust, letting you track usage securely.
Does the send_event tool support multiple OS versions or locales? +
Yes, the tool captures detailed system information like OS name, version, and locale. This lets you segment data accurately across different user environments.
What is the primary requirement for setting up the send_event tool? +
You must first subscribe to the server and enter your Aptabase App Key. Once that's done, your AI agent can start sending telemetry 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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Coveralls (Code Coverage Analytics API)
Track code coverage metrics via Coveralls — manage repositories, submit coverage reports, and monitor build statuses directly from your AI agent.
Upstash
Manage serverless Redis via Upstash REST API — execute commands, manage data structures and monitor your database from any AI agent.
Bubble.io (No-code Application Platform API)
Manage your Bubble.io application data and trigger backend workflows directly from any AI agent.
You might also like
SoundCloud
Manage your SoundCloud account — audit tracks, playlists, and followers via AI.
RocketLaunch.Live
Track rocket launches worldwide — search upcoming launches, vehicles, companies, locations and missions.
HireVue
Streamline your recruitment process via HireVue — manage candidates, schedule interviews, and track positions directly from any AI agent.