Ingestion API

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

POST /v1/ingest HTTP/1.1
Host: api.ingest.eu.logflux.io
Authorization: Bearer eu-lf_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6
Content-Type: multipart/mixed; boundary=logflux

--logflux
X-LF-Entry-Type: 1
X-LF-Payload-Type: 1
X-LF-Key-ID: 7f8a9b0c-1d2e-3f4a-5b6c-7d8e9f0a1b2c
X-LF-Nonce: YWJjZGVmZ2hpamts
X-LF-Timestamp: 2026-03-15T14:30:45.123Z

<raw binary AES-GCM ciphertext>
--logflux--

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

POST /v1/ingest HTTP/1.1
Host: api.ingest.eu.logflux.io
Authorization: Bearer eu-lf_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6
Content-Type: multipart/mixed; boundary=logflux

--logflux
X-LF-Entry-Type: 1
X-LF-Payload-Type: 1
X-LF-Key-ID: 7f8a9b0c-1d2e-3f4a-5b6c-7d8e9f0a1b2c
X-LF-Nonce: YWJjZGVmZ2hpamts
X-LF-Timestamp: 2026-03-15T14:30:45.123Z

<raw binary ciphertext for entry 1>
--logflux
X-LF-Entry-Type: 3
X-LF-Payload-Type: 1
X-LF-Key-ID: 7f8a9b0c-1d2e-3f4a-5b6c-7d8e9f0a1b2c
X-LF-Nonce: bm9uY2UxMjM0NTY=
X-LF-Timestamp: 2026-03-15T14:30:45.456Z

<raw binary ciphertext for entry 2>
--logflux--

1
2
3
4
5
6
7
8
9

{
  "status": "success",
  "message": "Log entry ingested successfully",
  "request_id": "550e8400-e29b-41d4-a716-446655440000",
  "timestamp": "2026-03-15T14:30:45.200Z",
  "data": {
    "entry_id": "1234567890123456789"
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

{
  "status": "success",
  "message": "Batch ingestion complete",
  "request_id": "550e8400-e29b-41d4-a716-446655440001",
  "timestamp": "2026-03-15T14:30:45.300Z",
  "data": {
    "total": 50,
    "successful": 49,
    "failed": 1,
    "entries": [
      {"index": 0, "entry_id": "1234567890123456789", "status": "success"},
      {"index": 1, "entry_id": "1234567890123456790", "status": "success"}
    ],
    "errors": [
      {"index": 12, "error": "invalid nonce length", "code": "VALIDATION_ERROR"}
    ]
  }
}

1
2
3
4
5
6
7
8

POST /v1/handshake/init HTTP/1.1
Host: api.ingest.eu.logflux.io
Authorization: Bearer eu-lf_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6
Content-Type: application/json

{
  "api_key": "eu-lf_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{
  "status": "success",
  "data": {
    "public_key": "-----BEGIN PUBLIC KEY-----\nMIICIjANBg...\n-----END PUBLIC KEY-----",
    "encryption_mode": 1,
    "max_payload_size": 1048576,
    "max_batch_size": 1000,
    "supports_multipart": true
  }
}

1
2
3
4
5
6
7
8
9

POST /v1/handshake/complete HTTP/1.1
Host: api.ingest.eu.logflux.io
Authorization: Bearer eu-lf_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6
Content-Type: application/json

{
  "api_key": "eu-lf_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6",
  "encrypted_secret": "<base64-encoded RSA-encrypted AES key>"
}

1
2
3
4
5
6

{
  "status": "success",
  "data": {
    "key_id": "7f8a9b0c-1d2e-3f4a-5b6c-7d8e9f0a1b2c"
  }
}

1
2
3
4

X-RateLimit-Limit: 600
X-RateLimit-Remaining: 599
X-RateLimit-Reset: 1710518445
Retry-After: 30

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

package main

import (
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "net/textproto"
    "time"
)

func ingestLog(apiKey, keyID string, aesKey []byte, payload []byte) error {
    // Generate unique nonce
    nonce := make([]byte, 12)
    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
        return err
    }

    // Encrypt with AES-256-GCM
    block, _ := aes.NewCipher(aesKey)
    gcm, _ := cipher.NewGCM(block)
    ciphertext := gcm.Seal(nil, nonce, payload, nil)

    // Build multipart request
    var body bytes.Buffer
    writer := multipart.NewWriter(&body)
    writer.SetBoundary("logflux")

    header := make(textproto.MIMEHeader)
    header.Set("X-LF-Entry-Type", "1")
    header.Set("X-LF-Payload-Type", "1")
    header.Set("X-LF-Key-ID", keyID)
    header.Set("X-LF-Nonce", base64.StdEncoding.EncodeToString(nonce))
    header.Set("X-LF-Timestamp", time.Now().UTC().Format(time.RFC3339Nano))

    part, _ := writer.CreatePart(header)
    part.Write(ciphertext)
    writer.Close()

    // Send request
    req, _ := http.NewRequest("POST",
        "https://api.ingest.eu.logflux.io/v1/ingest", &body)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "multipart/mixed; boundary=logflux")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    if resp.StatusCode != 200 {
        return fmt.Errorf("ingestion failed: %d", resp.StatusCode)
    }
    return nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

import os
import base64
import requests
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from datetime import datetime, timezone

def ingest_log(api_key: str, key_id: str, aes_key: bytes, payload: bytes):
    # Generate unique nonce
    nonce = os.urandom(12)

    # Encrypt with AES-256-GCM
    gcm = AESGCM(aes_key)
    ciphertext = gcm.encrypt(nonce, payload, None)

    # Build multipart/mixed body
    boundary = "logflux"
    timestamp = datetime.now(timezone.utc).isoformat()
    body = (
        f"--{boundary}\r\n"
        f"X-LF-Entry-Type: 1\r\n"
        f"X-LF-Payload-Type: 1\r\n"
        f"X-LF-Key-ID: {key_id}\r\n"
        f"X-LF-Nonce: {base64.b64encode(nonce).decode()}\r\n"
        f"X-LF-Timestamp: {timestamp}\r\n"
        f"\r\n"
    ).encode() + ciphertext + f"\r\n--{boundary}--\r\n".encode()

    # Send request
    resp = requests.post(
        "https://api.ingest.eu.logflux.io/v1/ingest",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": f"multipart/mixed; boundary={boundary}",
        },
        data=body,
    )
    resp.raise_for_status()
    return resp.json()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Note: This example shows the structure. In practice, you need to
# encrypt the payload with AES-GCM first using your session key.

curl -X POST "https://api.ingest.eu.logflux.io/v1/ingest" \
  -H "Authorization: Bearer eu-lf_a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6" \
  -H "Content-Type: multipart/mixed; boundary=logflux" \
  --data-binary @- << 'EOF'
--logflux
X-LF-Entry-Type: 1
X-LF-Payload-Type: 1
X-LF-Key-ID: 7f8a9b0c-1d2e-3f4a-5b6c-7d8e9f0a1b2c
X-LF-Nonce: YWJjZGVmZ2hpamts
X-LF-Timestamp: 2026-03-15T14:30:45.123Z

<binary ciphertext here>
--logflux--
EOF