Documentation

curl -X POST https://ingest.getepok.dev/insert/elasticsearch/_bulk \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '
{"create":{}}
{"_msg":"Application started successfully","level":"info","service":"api","_time":"2026-02-21T00:00:00Z"}
{"create":{}}
{"_msg":"GET /api/users 200 42ms","level":"info","service":"api","status_code":200,"duration_ms":42}
'

# /etc/fluent-bit/fluent-bit.conf

[INPUT]
    Name         tail
    Path         /var/log/app/*.log
    Tag          app

[OUTPUT]
    Name         loki
    Match        *
    Host         ingest.getepok.dev
    Port         443
    TLS          On
    HTTP_User    YOUR_API_KEY
    HTTP_Passwd  x
    Labels       job=fluentbit, host=my-server
    drop_single_key on

# vector.toml

[sources.app_logs]
type = "file"
include = ["/var/log/app/*.log"]

[sinks.epok]
type = "loki"
inputs = ["app_logs"]
endpoint = "https://ingest.getepok.dev"

[sinks.epok.encoding]
codec = "json"

[sinks.epok.auth]
strategy = "bearer"
token = "YOUR_API_KEY"

[sinks.epok.labels]
service = "{{ service }}"
host = "{{ host }}"

# promtail-config.yml

clients:
  - url: https://ingest.getepok.dev/loki/api/v1/push
    basic_auth:
      username: YOUR_API_KEY
      password: x

scrape_configs:
  - job_name: app
    static_configs:
      - targets: [localhost]
        labels:
          app: api
          __path__: /var/log/app/*.log

import time, httpx

resp = httpx.post(
    "https://ingest.getepok.dev/loki/api/v1/push",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={
        "streams": [{
            "stream": {"app": "myapp", "env": "production"},
            "values": [[
                str(int(time.time())) + "000000000",
                "User signup completed for user_id=4821"
            ]]
        }]
    }
)

// No npm install needed — fetch is built-in on Node 18+.

const API_KEY = process.env.EPOK_API_KEY;

async function log(entries) {
  const body = entries
    .flatMap((e) => [
      JSON.stringify({ create: {} }),
      JSON.stringify({ _time: new Date().toISOString(), ...e }),
    ])
    .join("\n") + "\n";

  const r = await fetch(
    "https://ingest.getepok.dev/insert/elasticsearch/_bulk",
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${API_KEY}`,
        "Content-Type": "application/x-ndjson",
      },
      body,
    },
  );
  if (!r.ok) throw new Error(`epok ingest failed: ${r.status}`);
}

await log([
  { level: "info", service: "api", _msg: "signup ok user_id=4821" },
  { level: "error", service: "api", _msg: "payment failed order_id=9012" },
]);

package epok

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"
)

type Entry struct {
	Time    string `json:"_time"`
	Msg     string `json:"_msg"`
	Level   string `json:"level"`
	Service string `json:"service"`
}

var client = &http.Client{Timeout: 30 * time.Second}

func Send(entries []Entry) error {
	var buf bytes.Buffer
	for _, e := range entries {
		buf.WriteString(`{"create":{}}` + "\n")
		if err := json.NewEncoder(&buf).Encode(e); err != nil {
			return err
		}
	}
	req, err := http.NewRequest("POST",
		"https://ingest.getepok.dev/insert/elasticsearch/_bulk", &buf)
	if err != nil {
		return err
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("EPOK_API_KEY"))
	req.Header.Set("Content-Type", "application/x-ndjson")
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()
	if resp.StatusCode >= 300 {
		return fmt.Errorf("epok ingest failed: %s", resp.Status)
	}
	return nil
}

# otel-collector-config.yml

exporters:
  otlphttp:
    endpoint: https://ingest.getepok.dev
    headers:
      Authorization: "Bearer YOUR_API_KEY"

service:
  pipelines:
    logs:
      receivers: [otlp]
      exporters: [otlphttp]

curl -X POST https://ingest.getepok.dev/loki/api/v1/push \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
  "streams": [{
    "stream": {"app": "api", "env": "production"},
    "values": [
      ["1771632000000000000", "Application started successfully"],
      ["1771632001000000000", "GET /api/users 200 42ms"]
    ]
  }]
}'

# /etc/fluentd/fluent.conf

<source>
  @type tail
  path /var/log/app/*.log
  tag app.logs
</source>

<match app.**>
  @type http
  endpoint https://ingest.getepok.dev/api/v1/fluentd
  headers {"Authorization": "Bearer YOUR_API_KEY"}
  json_array false
  <format>
    @type json
  </format>
</match>

# /etc/logstash/conf.d/epok.conf

output {
  elasticsearch {
    hosts         => ["https://ingest.getepok.dev"]
    index         => "logs"
    user          => "${EPOK_API_KEY}"
    password      => "x"
    ssl_enabled   => true
    http_compression => true
  }
}

# filebeat.yml

filebeat.inputs:
  - type: filestream
    id: app-logs
    paths:
      - /var/log/app/*.log

output.elasticsearch:
  hosts: ["https://ingest.getepok.dev"]
  api_key: "${EPOK_API_KEY}"
  compression_level: 3
  bulk_max_size: 1000

# /etc/rsyslog.d/50-epok.conf

module(load="omhttp")

action(
  type="omhttp"
  server="ingest.getepok.dev"
  serverport="443"
  usehttps="on"
  restpath="api/v1/syslog"
  httpcontenttype="text/plain"
  httpheaders=["Authorization: Bearer YOUR_API_KEY"]
  template="RSYSLOG_SyslogProtocol23Format"
  action.resumeRetryCount="-1"
  queue.type="LinkedList"
  queue.size="50000"
)

# vector.toml — drop-in Splunk HEC shim

[sources.splunk_in]
type = "splunk_hec_logs"
address = "0.0.0.0:8088"
token = "YOUR_INTERNAL_HEC_TOKEN"

[sinks.epok]
type = "elasticsearch"
inputs = ["splunk_in"]
endpoint = "https://ingest.getepok.dev"
bulk.index = "logs"

[sinks.epok.auth]
strategy = "basic"
user = "YOUR_API_KEY"
password = "x"

# Send a single syslog frame directly with curl
curl -X POST https://ingest.getepok.dev/api/v1/syslog \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: text/plain' \
  --data-binary '<134>1 2026-04-08T12:34:56Z host01 myapp 1234 - - User signup failed for user_id=4821'

# Or batch many frames in one POST (newline-delimited)
curl -X POST https://ingest.getepok.dev/api/v1/syslog \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: text/plain' \
  --data-binary @syslog-batch.txt

# /etc/fluent-bit/syslog-relay.conf

[INPUT]
    Name        syslog
    Listen      0.0.0.0
    Port        514
    Mode        udp

[OUTPUT]
    Name         loki
    Match        *
    Host         ingest.getepok.dev
    Port         443
    TLS          On
    HTTP_User    YOUR_API_KEY
    HTTP_Passwd  x
    Labels       job=syslog-relay

# Create a Lambda subscription filter that POSTs to Epok.
# CloudWatch → Lambda → Epok

import base64, urllib3

EPOK_URL = "https://ingest.getepok.dev/api/v1/cloudwatch"
API_KEY = "YOUR_API_KEY"
http = urllib3.PoolManager()

def handler(event, context):
    # CloudWatch payload is base64-encoded gzip, send as-is
    compressed = base64.b64decode(event["awslogs"]["data"])
    http.request("POST", EPOK_URL,
        body=compressed,
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Encoding": "gzip",
            "Content-Type": "application/json"
        })

# GCP Cloud Logging → Pub/Sub → Cloud Function → Epok
# 1. Create a log sink that routes to a Pub/Sub topic
# 2. Deploy this Cloud Function as a Pub/Sub subscriber

import base64, json, requests

EPOK_URL = "https://ingest.getepok.dev/api/v1/ingest"
API_KEY = "YOUR_API_KEY"

def handle_log(event, context):
    data = json.loads(base64.b64decode(event["data"]))
    entry = {
        "_msg": data.get("textPayload", json.dumps(data.get("jsonPayload", {}))),
        "level": data.get("severity", "info").lower(),
        "service": data.get("resource", {}).get("type", "gcp"),
        "_time": data.get("timestamp"),
    }
    requests.post(EPOK_URL,
        headers={"Authorization": f"Bearer {API_KEY}"},
        json=[entry])

curl -X POST https://ingest.getepok.dev/api/v1/ingest \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '[
  {"_msg": "User signed up", "level": "info", "service": "auth", "user_id": 4821},
  {"_msg": "Payment processed", "level": "info", "service": "billing", "amount": 29.99}
]'