Open Analytics — Video Player Analytics
AI-native video player analytics powered by EPAS open standard. Query your data with Claude, Cursor, or SQL — zero vendor lock-in.
Get StartedFrom €199/mo · 14-day free trial · No credit card required
Real-time QoE monitoring dashboard
Who Uses Open Analytics
Built for video streaming teams who need real-time insight into player quality, viewer engagement, and delivery performance.
OTT Platforms
Monitor real-time QoE across 10K+ concurrent viewers. Track startup time, buffering, and errors by device and geo.
- Startup time by region & device
- Concurrent viewer QoE score
- Error rate & rebuffering ratio
Live Streaming Events
Ensure broadcast-grade reliability. Real-time alerts when QoS degrades below SLA thresholds.
- Live latency & dropped frames
- SLA threshold breach alerts
- Bitrate stability over time
Content Creators
Understand viewer behavior. Which videos have the highest completion rates? Where do viewers drop off?
- Video completion rate by title
- Drop-off points & engagement depth
- Play events & pause patterns
Video CDN Operators
Measure CDN performance. Compare bitrate delivery across regions and identify edge server issues.
- Bitrate delivery by edge region
- CDN-to-CDN performance comparison
- Edge server error correlation
Your 14-Day Trial Journey
From zero to production analytics in four simple phases — no credit card required.
Deploy your analytics pipeline
5-minute setup via the OSC console. All 5 services (SmoothMQ, ClickHouse, Eventsink, Worker, Grafana) auto-configured and ready to receive events.
Integrate SDKs
Choose your platform — Web JS, Android Kotlin, or iOS Swift. Copy-paste 5–10 lines of SDK code and auto-track play, pause, buffering, and errors.
Analyze your data
Real-time QoE metrics in Grafana dashboards. Track startup time (<2s), rebuffering ratio (<1%), and query everything via ClickHouse SQL or MCP.
Export or upgrade
Export via CSV or SQL using the open EPAS format. Upgrade to Business at €199/mo, or cancel anytime — zero lock-in.
Track What Matters Most: Startup Time & Buffering
Open Analytics tracks the critical Quality of Experience (QoE) metrics that directly impact viewer retention and revenue.
Higher playthrough rates. Viewers abandon if >2s.
Longer sessions. >3% indicates serious delivery problems.
Lower churn. Track quality shifts and playback errors.
Instant visibility. ClickHouse queries return in milliseconds.
Features
Real-time Analytics
Track playback events, errors, and user behavior in real-time with ClickHouse.
Grafana Dashboards
Visualize your analytics data with pre-built Grafana dashboards.
EPAS Standard
Built on the open Eyevinn Player Analytics Specification. No vendor lock-in.
Open Source
Full transparency. Contribute, customize, and own your analytics stack.
Compliant by Design
Open Analytics meets EU Data Act (September 2025) requirements from day one — no additional compliance work needed.
Data Portability
EPAS open format: export your analytics to any backend — Datadog, Splunk, or your own infrastructure — without data conversion.
Zero Lock-in
Unlimited SQL access: ClickHouse credentials included. Run custom queries and export via CSV or JSON at any time.
Interoperability
ClickHouse MCP: AI agents can migrate your data to any destination automatically — interoperability built in.
Proprietary analytics platforms (using closed formats) will require costly compliance work. Open Analytics is compliant from day one — zero migration risk for European enterprises.
Simple, Transparent Pricing
Business
Everything you need for production workflows
- Unlimited productions
- Priority support
- Advanced features
- Cancel anytime
Start with a 14-day free trial. No commitment required.
What's Included
Complete Analytics Stack
Everything deployed automatically
- Player Analytics Eventsink - Ingest events from players
- SmoothMQ - Message queue for reliable processing
- Analytics Worker - Process and store events
- ClickHouse - Real-time analytics database
- Grafana - Visualization dashboards
Deploy with one click. Auto-configured and ready to use.
Frequently Asked Questions
EPAS (Eyevinn Player Analytics Specification) is an open standard for video player telemetry. It defines a common format for collecting and exchanging player analytics data, ensuring your metrics are portable across different platforms and tools. Unlike proprietary formats, EPAS gives you complete control over your data with zero vendor lock-in.
Open standards eliminate vendor lock-in and ensure data portability. With EPAS, you can export your analytics data to any backend or switch providers without losing historical data or rewriting your instrumentation. Your data remains yours, in a format that's universally readable and future-proof.
Unlike proprietary platforms that lock your data in their ecosystem, Open Analytics gives you complete freedom. You get direct access to your ClickHouse database, can export data in standard formats, and aren't tied to a single vendor's visualization tools or pricing model. It's the same powerful analytics capabilities without the restrictions.
Track all essential video player metrics including play/pause events, buffering, bitrate changes, video quality, error events, and playback completion. You can also capture custom metadata like content ID, user ID, device type, and any business-specific attributes. All data is stored in real-time for immediate analysis.
Yes! Open Analytics provides SDKs for Web (JavaScript), Android (Kotlin/Java), and iOS (Swift) that integrate with any video player. The SDKs handle event collection and transmission automatically, so you can instrument your player with just a few lines of code regardless of your player technology.
Absolutely not. You have full export capabilities and direct access to your ClickHouse database. Your data is stored in the open EPAS format, making it completely portable. You can export to CSV, integrate with other tools via SQL, or migrate to another platform without any data conversion required.
The Business plan includes unlimited productions, 5 fully managed services (Eventsink, SmoothMQ, Analytics Worker, ClickHouse, and Grafana), priority support, and advanced features. Everything is auto-configured and deployed with one click. Start with a 14-day free trial—no credit card required—and cancel anytime.
No installation or management required. Open Analytics is a fully managed deployment—we handle provisioning, configuration, updates, backups, and scaling automatically. You get production-ready analytics infrastructure without DevOps overhead, letting you focus on insights instead of infrastructure.
Yes. Open Analytics meets EU Data Act (September 2025) requirements from day one — no additional compliance work needed. The EPAS open format ensures data portability (export to any backend), direct ClickHouse SQL access eliminates lock-in (custom queries, CSV/JSON exports anytime), and ClickHouse MCP enables interoperability (AI agents can migrate data to any destination automatically). Proprietary platforms using closed formats will need costly compliance work; Open Analytics is compliant from day one.
Your Analytics Pipelines
Create New Pipeline
Security Reminder
Your Grafana dashboard is deployed with default credentials (admin/admin). Change these immediately after first login. We recommend using strong, unique passwords and enabling two-factor authentication. See Grafana security guide →
Need help integrating? Check the documentation for SDK setup.
SQL Access
Every Open Analytics pipeline includes direct SQL access to your ClickHouse database. Query your raw event data, build custom reports, and connect BI tools — all without vendor lock-in.
Connection Credentials
Per PipelineSelect a pipeline to view its ClickHouse connection details.
Schema Reference
player_eventsTable: player_events
All player events are stored in the
player_events table in the
analytics database.
CREATE TABLE analytics.player_events (
-- Identity
sessionId String, -- Unique session ID per viewer
correlationId String, -- Correlates events in same session
-- Event metadata
event_type String, -- 'play', 'pause', 'buffering', 'bitrate_changed',
-- 'error', 'heartbeat', 'stop', 'seek'
timestamp DateTime, -- Event timestamp (UTC)
-- Playback state
playhead Float64, -- Playback position in seconds
duration Float64, -- Content duration in seconds
startup_time_ms Int64, -- Time to first frame (ms), set on 'play'
bitrate Int64, -- Current bitrate (bps)
resolution String, -- e.g. '1920x1080'
-- Buffering
rebuffering_duration_ms Int64, -- Duration of this buffering event (ms)
playback_duration_ms Int64, -- Total playback time in session so far (ms)
-- Content & player metadata
content_id String, -- Your content identifier
content_url String, -- Stream URL
user_id String, -- Viewer identifier (optional)
device_type String, -- 'web', 'android', 'ios', 'ctv'
cdn String, -- CDN identifier (optional)
player_type String, -- Player technology
-- Error info
error_code String, -- Error code on 'error' events
error_message String -- Human-readable error description
) ENGINE = MergeTree()
ORDER BY (sessionId, timestamp);Example Queries
ClickHouse SQLAverage Startup Time by Device Type
Identify which devices have the slowest time-to-first-frame. Target: under 2 seconds.
SELECT
device_type,
AVG(startup_time_ms) AS avg_startup_ms,
ROUND(AVG(startup_time_ms) / 1000, 2) AS avg_startup_s,
COUNT(DISTINCT sessionId) AS sessions
FROM analytics.player_events
WHERE event_type = 'play'
AND timestamp > NOW() - INTERVAL 7 DAY
GROUP BY device_type
ORDER BY avg_startup_ms DESC;Rebuffering Ratio by CDN
Compare delivery quality across CDNs. Target: under 1%.
SELECT
cdn,
ROUND(
(SUM(rebuffering_duration_ms) / NULLIF(SUM(playback_duration_ms), 0)) * 100,
2
) AS rebuffering_ratio_pct,
COUNT(DISTINCT sessionId) AS sessions
FROM analytics.player_events
WHERE playback_duration_ms > 0
AND timestamp > NOW() - INTERVAL 7 DAY
GROUP BY cdn
ORDER BY rebuffering_ratio_pct DESC;Error Rate by Content
Find which content items trigger the most playback errors.
SELECT
content_id,
COUNT(*) AS total_errors,
COUNT(DISTINCT sessionId) AS affected_sessions,
topK(5)(error_code) AS top_error_codes
FROM analytics.player_events
WHERE event_type = 'error'
AND timestamp > NOW() - INTERVAL 7 DAY
GROUP BY content_id
ORDER BY total_errors DESC
LIMIT 20;Concurrent Viewers (Last Hour)
Approximate concurrent viewer count over the past hour in 5-minute buckets.
SELECT
toStartOfFiveMinute(timestamp) AS bucket,
COUNT(DISTINCT sessionId) AS concurrent_viewers
FROM analytics.player_events
WHERE event_type IN ('heartbeat', 'play')
AND timestamp > NOW() - INTERVAL 1 HOUR
GROUP BY bucket
ORDER BY bucket ASC;Bitrate Distribution
Understand what quality levels your viewers are experiencing.
SELECT
ROUND(bitrate / 1000000, 1) AS bitrate_mbps,
COUNT(*) AS event_count,
COUNT(DISTINCT sessionId) AS sessions
FROM analytics.player_events
WHERE event_type = 'bitrate_changed'
AND bitrate > 0
AND timestamp > NOW() - INTERVAL 7 DAY
GROUP BY bitrate_mbps
ORDER BY bitrate_mbps ASC;Export & BI Tools
IntegrationsExport to CSV (HTTP API)
Use the ClickHouse HTTP interface to download query results directly as CSV:
curl "https://{host}:8123/?database=analytics&user={username}&password={password}" \
--data "SELECT * FROM player_events WHERE timestamp > NOW() - INTERVAL 1 DAY FORMAT CSV" \
-o events.csvConnect BI Tools
ClickHouse supports JDBC and ODBC drivers for connecting BI tools:
AI-Native Analytics Access
Unique DifferentiatorConnect AI Assistants to Your Analytics Database
Open Analytics includes ClickHouse MCP (Model Context Protocol) support — AI assistants like Claude, Cursor, and GitHub Copilot can query your analytics database directly using natural language. No dashboards required. Just ask.
This is a unique capability not offered by Mux or Conviva: direct AI-agent access to your raw analytics database, at no extra cost.
What You Can Do
Setup: Local MCP Client (Claude Desktop / Cursor)
Add this to your Claude Desktop or Cursor MCP configuration. Replace the placeholders with your pipeline's connection credentials from the section above.
{
"mcpServers": {
"clickhouse": {
"command": "uv",
"args": ["run", "--with", "mcp-clickhouse", "--python", "3.10", "mcp-clickhouse"],
"env": {
"CLICKHOUSE_HOST": "{host}",
"CLICKHOUSE_PORT": "8123",
"CLICKHOUSE_USER": "{username}",
"CLICKHOUSE_PASSWORD": "{password}",
"CLICKHOUSE_DATABASE": "analytics",
"CLICKHOUSE_SECURE": "true"
}
}
}
}Setup: Remote MCP (ClickHouse Cloud)
ClickHouse also offers a hosted remote MCP server (public beta). Connect any MCP-compatible AI assistant without running a local process — ideal for agentic workflows and team environments.
SDK Documentation
Integrate video player analytics into your applications with our official SDKs. Built on the Eyevinn Player Analytics Specification (EPAS) for standardized, vendor-neutral event tracking.
Getting Started
All Open Analytics SDKs follow the same pattern: initialize with your Eventsink URL, attach to your player, and analytics data flows automatically to your dashboard.
- Automatic event tracking for play, pause, seek, buffering, and errors
- Periodic heartbeat events for engagement metrics
- Bitrate and quality change monitoring
- Custom metadata support for content identification
Installation
npm install @eyevinn/player-analytics-client-sdk-webQuick Start
The PlayerAnalyticsConnector automatically captures events from your HTML5 video element:
import { PlayerAnalyticsConnector } from "@eyevinn/player-analytics-client-sdk-web";
const analytics = new PlayerAnalyticsConnector("YOUR_EVENTSINK_URL");
await analytics.init({
sessionId: crypto.randomUUID(),
heartbeatInterval: 30000
});
const videoElement = document.querySelector("video");
analytics.load(videoElement);
// When playback ends
analytics.reportStop();
analytics.destroy();Features
Installation
Add JitPack repository and dependency:
// settings.gradle
maven { url 'https://jitpack.io' }
// build.gradle
implementation("com.github.Eyevinn:player-analytics-client-sdk-android:1.0.0")Quick Start with ExoPlayer
val tracker = VideoAnalyticsTracker.Builder(context, exoPlayer)
.setEventSinkUrl("YOUR_EVENTSINK_URL")
.setContentTitle("Video Title")
.setHeartbeatInterval(30_000L)
.build()
tracker.startTracking()
exoPlayer.play()
// In onDestroy()
tracker.stopTracking("user_exit")
tracker.release()Features
Installation (Swift Package Manager)
File → Swift Packages → Add Package Dependency...
https://github.com/Eyevinn/player-analytics-client-sdk-swiftQuick Start with AVPlayer
import VideoStreamTracker
class VideoPlayerViewController: UIViewController {
var player: AVPlayer!
var logger: AVPlayerEventLogger!
override func viewDidLoad() {
super.viewDidLoad()
player = AVPlayer(url: videoURL)
logger = AVPlayerEventLogger(
player: player,
eventSinkUrl: URL(string: "YOUR_EVENTSINK_URL")!
)
}
}