DPTCloud
Back to articles
Technology Insight

Building a High-Performance Private API Analytics Platform with ClickHouse, Vector.dev, and Nginx

June 4, 2026

Introduction to Modern API Analytics

In today's data-driven business landscape, APIs serve as the central nervous system of modern software architectures. Every request carries vital information regarding system health, user behavior, and operational efficiency. However, as API traffic scales into millions of daily requests, traditional logging mechanisms and relational databases quickly become performance bottlenecks.

Many organizations turn to third-party Software-as-a-Service (SaaS) analytics platforms. While convenient, these solutions come with significant drawbacks, including skyrocketing volume-based costs, vendor lock-in, and compliance risks regarding data privacy (such as GDPR or HIPAA). Building a Private API Analytics Platform allows your organization to retain absolute data ownership, customize metrics to your exact business needs, and maintain predictable infrastructure costs.

This technical guide demonstrates how to architect and deploy a production-grade, self-hosted API analytics pipeline using an industry-proven open-source stack: Nginx as the reverse proxy, Vector.dev as the high-throughput log aggregator, and ClickHouse as the ultra-fast columnar analytical database.

The Architecture: Why This Stack?

An effective analytics pipeline requires decoupled layers for traffic routing, data collection, and analytical storage. By separating these concerns, each component can be scaled independently without risking system availability.

  • Nginx (The Traffic Layer): Acts as the front line, routing API requests and emitting structured, high-granularity access logs without adding measurable latency to the client response.
  • Vector.dev (The Ingestion Layer): A lightweight, ultra-fast tool written in Rust. It monitors Nginx log streams, parses and enriches the raw data, buffers it safely against spikes, and batches writes efficiently into the database.
  • ClickHouse (The Storage & Analytics Layer): An open-source, columnar Management System (DBMS) designed specifically for Online Analytical Processing (OLAP). It compresses billions of rows efficiently and executes complex analytical queries in milliseconds.

Step 1: Configuring Nginx for Structured Logging

To analyze API traffic effectively, Nginx must capture more than just basic HTTP status codes. We need to configure Nginx to output logs in a structured JSON format, including performance metrics like upstream response time and byte counts.

Modify your Nginx configuration file (typically found at /etc/nginx/nginx.conf) within the http block to define a custom log format:

log_format api_analytics escape=json '{
  "time_local": "$time_local",
  "request_id": "$request_id",
  "remote_addr": "$remote_addr",
  "request_method": "$request_method",
  "request_uri": "$request_uri",
  "status": "$status",
  "body_bytes_sent": "$body_bytes_sent",
  "request_time": "$request_time",
  "upstream_response_time": "$upstream_response_time",
  "http_referrer": "$http_referer",
  "http_user_agent": "$http_user_agent"
}';

Next, apply this log format to your specific API virtual host configuration block:

server {
    listen 80;
    server_name api.yourdomain.com;

    access_log /var/log/nginx/api_access.log api_analytics;

    location / {
        proxy_pass http://your_upstream_service;
        # Additional proxy settings
    }
}

Reload Nginx using nginx -s reload to start emitting clean, machine-readable JSON logs into your dedicated log file.

Step 2: Designing the ClickHouse Database Schema

ClickHouse owes its blazing speed to its columnar storage engine. Instead of storing data row-by-row, it groups data by columns, which drastically reduces disk I/O when aggregating metrics like average latency or error rates.

Connect to your ClickHouse instance and create a dedicated database along with an optimized table structure using the MergeTree engine:

CREATE DATABASE IF NOT EXISTS api_analytics;

CREATE TABLE IF NOT EXISTS api_analytics.request_logs (
    timestamp DateTime,
    request_id String,
    remote_addr String,
    method LowCardinality(String),
    uri String,
    status UInt16,
    bytes_sent UInt64,
    request_time Float32,
    upstream_time Float32,
    user_agent String
)
ENGINE = MergeTree()
PARTITION BY toYYYYMM(timestamp)
ORDER BY (status, method, uri, timestamp)
SETTINGS index_granularity = 8192;

Optimization Tip: We utilize the LowCardinality(String) type for the HTTP method column. Since there are very few unique HTTP methods (GET, POST, etc.), this optimization saves significant disk space and speeds up query execution filtering.

Step 3: Setting Up Vector.dev for Log Ingestion

With Nginx writing JSON logs and ClickHouse ready to receive them, Vector acts as the glue. Vector reads the log file, transforms the text into strongly-typed values, and manages the batching strategy required by ClickHouse.

Create a vector.toml configuration file to define the pipeline pipeline architecture:

[sources.nginx_logs]
type = "file"
include = ["/var/log/nginx/api_access.log"]
read_from = "beginning"

[transforms.parse_json]
type = "remap"
inputs = ["nginx_logs"]
source = """
parsed = parse_json!(.message)

# Map and transform data types to match ClickHouse schema
.timestamp = parse_timestamp!(parsed.time_local, format: "%d/%b/%Y:%H:%M:%S %z")
.request_id = parsed.request_id
.remote_addr = parsed.remote_addr
.method = parsed.request_method
.uri = parsed.request_uri
.status = to_int!(parsed.status)
.bytes_sent = to_int!(parsed.body_bytes_sent)
.request_time = to_float!(parsed.request_time)
.upstream_time = to_float!(parsed.upstream_response_time)
.user_agent = parsed.http_user_agent

del(.message)
"""

[sinks.clickhouse_output]
type = "clickhouse"
inputs = ["parse_json"]
endpoint = "http://localhost:8123"
database = "api_analytics"
table = "request_logs"
skip_unknown = true

[sinks.clickhouse_output.batch]
max_events = 5000
timeout_secs = 5

The batch configuration here is critical. ClickHouse is optimized for large, batched inserts rather than single, frequent row operations. This setup ensures Vector flushes data either every 5,000 requests or every 5 seconds, maximizing write performance.

Step 4: Querying Your Private Analytics Platform

Once your pipeline is active, data will stream instantly into ClickHouse. You can now execute complex analytical queries with near-instantaneous feedback. Here are three standard queries utilized by engineering and product teams:

1. Total Requests and Error Rates over Time

SELECT 
    toStartOfHour(timestamp) AS hour,
    count() AS total_requests,
    countIf(status >= 400) AS total_errors,
    (total_errors / total_requests) * 100 AS error_percentage
FROM api_analytics.request_logs
GROUP BY hour
ORDER BY hour DESC;

2. 95th and 99th Percentile Latency Analysis

SELECT 
    uri,
    count() AS hits,
    quantile(0.95)(request_time) AS p95_latency,
    quantile(0.99)(request_time) AS p99_latency
FROM api_analytics.request_logs
GROUP BY uri
HAVING hits > 100
ORDER BY p95_latency DESC
LIMIT 10;

Security and Production Considerations

Deploying an internal analytics engine requires adhering to strict security and maintenance protocols to maintain long-term stability:

  1. Log Rotation: Ensure that logrotate is configured for Nginx. Vector gracefully handles truncated or rotated log files without duplicating entries.
  2. Data Retention Policies: Raw logs accumulate rapidly. Implement a ClickHouse TTL (Time-To-Live) policy to automatically drop records older than 30 or 90 days depending on corporate requirements.
  3. Network Security: Restrict your ClickHouse and Vector ports using firewalls. Never expose ClickHouse endpoints (ports 8123 or 9000) directly to the public internet.

Conclusion

By leveraging Nginx, Vector.dev, and ClickHouse, you have bypassed restrictive SaaS costs and built a private, real-time analytics engine capable of handling enterprise-scale traffic. Not only does this safeguard sensitive user data, but it also empowers your development team with the fast operational insights needed to monitor APIs efficiently. As a next step, you can easily plug open-source dashboard tools like Grafana into ClickHouse to visualize your metrics in real-time.