Getting Started

Open-source log management. Privacy-first. Self-hosted or cloud.

Deployment Options

Managed Cloud

Zero setup required. Start logging in seconds.

Instant access, no installation
Automatic updates & backups
99.9% uptime SLA
API: api.logtide.dev

Self-Hosted

Full control. Privacy-first. Docker deployment.

100% data ownership
GDPR-compliant by design
One-command deployment
License: AGPLv3

Self-Hosted Quick Start

Prerequisites

Docker Engine - Container runtime
Docker Compose - Multi-container orchestration

That's it! No Node.js, no build tools, no database setup. Uses pre-built images from Docker Hub.

Installation (2 minutes)

# 1. Create project directory
mkdir logtide && cd logtide

# 2. Download configuration files
curl -O https://raw.githubusercontent.com/logtide-dev/logtide/main/docker/docker-compose.yml
curl -O https://raw.githubusercontent.com/logtide-dev/logtide/main/docker/.env.example
mv .env.example .env

# 3. Configure your .env file (IMPORTANT!)
nano .env
# Required changes:
#   - DB_PASSWORD: set a secure password
#   - REDIS_PASSWORD: set a secure password
#   - API_KEY_SECRET: run "openssl rand -base64 32" and paste the result
#   - PUBLIC_API_URL: set to http://YOUR_SERVER_IP:8080 (if accessing remotely)

# 4. Start LogTide
docker compose up -d

# 5. Access the dashboard
# Frontend: http://localhost:3000
# API: http://localhost:8080

# Optional: Enable Docker log collection
# Download Fluent Bit configs and restart with --profile logging
# curl -O https://raw.githubusercontent.com/logtide-dev/logtide/main/docker/{fluent-bit.conf,parsers.conf,extract_container_id.lua,map_syslog_level.lua,wrap_logs.lua}
# docker compose --profile logging up -d

What happens automatically

Pulls pre-built images from Docker Hub
Starts PostgreSQL + TimescaleDB (database)
Starts Redis (queue & cache) - optional since v0.5.0
Runs database migrations
Starts backend API & worker
Starts frontend dashboard

Required Configuration

Edit your .env file and set these variables:

Variable	Description
DB_PASSWORD	PostgreSQL database password
REDIS_PASSWORD	Redis password (optional - Redis not required since v0.5.0)
API_KEY_SECRET	Encryption key (32+ characters). Generate with: `openssl rand -base64 32`
PUBLIC_API_URL	Required for remote access. Set to `http://YOUR_SERVER_IP:8080` if accessing from another machine

Accessing from another machine? You must set PUBLIC_API_URL to your server's IP address (e.g., http://192.168.1.100:8080). Without this, the frontend will try to reach localhost:8080 which won't work remotely.

Database migrations run automatically on first start.

Docker Images

Pre-built images are available from:

Docker Hub: logtide/backend, logtide/frontend
GitHub: ghcr.io/logtide-dev/logtide-backend

Pin versions in production: LOGTIDE_BACKEND_IMAGE=logtide/backend:0.6.1

Troubleshooting

"Failed to Fetch" or CORS Errors

This is the most common issue. If you see "Failed to fetch", "Network Error", or CORS errors in the browser console, the frontend cannot reach the backend API.

Symptoms:

• Login page shows "Failed to fetch" or "Network Error"
• Browser console shows CORS errors or requests to localhost:8080
• Firefox shows "TypeError: NetworkError when attempting to fetch resource"

Cause:

You're accessing LogTide from a different machine than where it's running. The frontend defaults to localhost:8080 which only works when your browser is on the same machine as Docker.

Solution:

Set PUBLIC_API_URL in your .env file to your server's IP:

# Replace with your server's actual IP address
PUBLIC_API_URL=http://192.168.1.100:8080

Then restart the frontend:

docker compose restart frontend

Verify the backend is running:

Before blaming the frontend, confirm the API is accessible:

# From your local machine (replace IP with your server's IP)
curl http://192.168.1.100:8080/health

# Expected response:
# {"status":"ok","timestamp":"...","version":"0.4.2"}

If this fails, the backend isn't running correctly — check the logs with docker compose logs backend.

Containers Not Starting / Unhealthy

Check container logs to identify the issue:

# Check all container status
docker compose ps

# View logs for a specific service
docker compose logs backend
docker compose logs postgres
docker compose logs redis

Backend Configuration Errors

If the backend container keeps restarting or fails health checks, check the logs for configuration errors:

docker compose logs backend | head -50

Common issues:

API_KEY_SECRET too short: Must be at least 32 characters. Generate with: openssl rand -base64 32
Empty DB_PASSWORD or REDIS_PASSWORD: These must be set in your .env file
Invalid DATABASE_URL: Check that DB_USER, DB_PASSWORD, and DB_NAME are all set correctly

Fluent Bit Volume Mount Errors

If you see errors about mounting files when using --profile logging, you need to download the Fluent Bit configuration files first:

# Download all required Fluent Bit config files
curl -O https://raw.githubusercontent.com/logtide-dev/logtide/main/docker/fluent-bit.conf
curl -O https://raw.githubusercontent.com/logtide-dev/logtide/main/docker/parsers.conf
curl -O https://raw.githubusercontent.com/logtide-dev/logtide/main/docker/extract_container_id.lua
curl -O https://raw.githubusercontent.com/logtide-dev/logtide/main/docker/map_syslog_level.lua
curl -O https://raw.githubusercontent.com/logtide-dev/logtide/main/docker/wrap_logs.lua

# Now start with logging profile
docker compose --profile logging up -d

These files must be in the same directory as your docker-compose.yml.

First Steps

1. Create Your Organization

After logging in, create your first organization to get started. Organizations are top-level containers for your projects.

2. Create a Project

Each organization can have multiple projects (e.g., "production", "staging"). Projects isolate logs and have their own API keys.

3. Generate an API Key

In your project settings, create an API key to start sending logs. Save it securely - it's shown only once!

4. Send Your First Log

Choose your preferred method to start sending logs to LogTide:

The simplest way to test log ingestion using curl:

Cloud (api.logtide.dev)

curl -X POST https://api.logtide.dev/api/v1/ingest \
  -H "X-API-Key: lp_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "logs": [{
      "time": "2025-01-23T10:30:00Z",
      "service": "my-app",
      "level": "info",
      "message": "Hello from LogTide Cloud!",
      "metadata": { "environment": "production" }
    }]
  }'

Self-Hosted

curl -X POST http://localhost:8080/api/v1/ingest \
  -H "X-API-Key: lp_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "logs": [{
      "time": "2025-01-23T10:30:00Z",
      "service": "my-app",
      "level": "info",
      "message": "Hello from LogTide!",
      "metadata": { "environment": "production" }
    }]
  }'

Send logs from Python using the requests library (no SDK needed):

import requests
from datetime import datetime, timezone

# Configuration
API_URL = "https://api.logtide.dev/api/v1/ingest"  # or http://localhost:8080 for self-hosted
API_KEY = "lp_your_api_key_here"

# Send a log
response = requests.post(
    API_URL,
    headers={
        "X-API-Key": API_KEY,
        "Content-Type": "application/json"
    },
    json={
        "logs": [{
            "time": datetime.now(timezone.utc).isoformat(),
            "service": "my-python-app",
            "level": "info",
            "message": "Hello from Python!",
            "metadata": {"user_id": 123}
        }]
    }
)

print(f"Status: {response.status_code}")

For production use, consider the Python SDK with retry logic and batching.

Send logs from Node.js using fetch (no SDK needed):

// Node.js 18+ (native fetch) or install node-fetch
const API_URL = "https://api.logtide.dev/api/v1/ingest"; // or http://localhost:8080
const API_KEY = "lp_your_api_key_here";

async function sendLog() {
  const response = await fetch(API_URL, {
    method: "POST",
    headers: {
      "X-API-Key": API_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      logs: [{
        time: new Date().toISOString(),
        service: "my-node-app",
        level: "info",
        message: "Hello from Node.js!",
        metadata: { userId: 123 }
      }]
    })
  });

  console.log('Status: ' + response.status);
}

sendLog();

For production use, consider the Node.js SDK with circuit breaker and batching.

Automatically collect logs from Docker containers using Fluent Bit:

# Add to your docker-compose.yml
services:
  my-app:
    image: my-app:latest
    # Your app just writes to stdout - no code changes needed!

  fluent-bit:
    image: fluent/fluent-bit:4.2.2  # or cr.fluentbit.io/fluent/fluent-bit:4.2.2 for ARM64
    volumes:
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      LOGTIDE_API_KEY: lp_your_api_key_here
      LOGTIDE_API_HOST: api.logtide.dev  # or backend for self-hosted

See the full No-SDK Setup guide for complete Fluent Bit configuration. For ARM64/Raspberry Pi, use cr.fluentbit.io/fluent/fluent-bit:4.2.2.

Use OpenTelemetry for vendor-neutral instrumentation:

# Install OpenTelemetry packages (Node.js example)
npm install @opentelemetry/api-logs @opentelemetry/sdk-logs \
  @opentelemetry/exporter-logs-otlp-http

import { logs, SeverityNumber } from '@opentelemetry/api-logs';
import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
import { LoggerProvider, BatchLogRecordProcessor } from '@opentelemetry/sdk-logs';

// Configure exporter
const exporter = new OTLPLogExporter({
  url: 'https://api.logtide.dev/v1/otlp/logs', // or localhost:8080
  headers: { 'X-API-Key': 'lp_your_api_key_here' },
});

// Setup provider
const provider = new LoggerProvider();
provider.addLogRecordProcessor(new BatchLogRecordProcessor(exporter));
logs.setGlobalLoggerProvider(provider);

// Send a log
const logger = logs.getLogger('my-app');
logger.emit({
  severityNumber: SeverityNumber.INFO,
  body: 'Hello from OpenTelemetry!',
  attributes: { 'user.id': '123' },
});

See the full OpenTelemetry guide for Python, Go, and collector setup.

Next Steps

Use an SDK

Official SDKs for Node.js, Python, PHP, and Kotlin

API Reference

Explore all available API endpoints and examples

Deployment Guide

Production deployment, SSL setup, and best practices

Architecture

Understand how LogTide works under the hood

Edit this page on GitHub