Deploy and Host Parseable on Railway

Built for an LLM agent to deploy and use. There is no wizard and no form to fill in: an admin password is generated at deploy time, and the contract below lists every URL, variable name and the one script that proves it works. Create a log stream, ship logs with a single curl, and query them with SQL.

Parseable is an open-source (AGPL-3.0) log analytics database written in Rust: it stores logs as compressed Parquet files and answers SQL queries over them. This template runs the official Parseable 2.8.0 image, pinned by digest, in local-store mode with the data on a Railway volume. Parseable's Docker Hub image stops at 2.8.0, which is why that is the version here.

About Hosting Parseable

This template runs one service with a volume at /data. Logs that arrive are buffered under /data/staging and written as Parquet under /data/store, so streams and their data are still there after a redeploy. The admin user is admin and the password is the generated variable P_PASSWORD; every API call needs it. Usage telemetry is switched off. Parseable also listens on port 8001 (live tail) and 8002 (Arrow Flight) inside the container; only the HTTP API on 8080 is exposed publicly.

Agent contract

Public URL: https:// plus the RAILWAY_PUBLIC_DOMAIN of the parseable service, also published as the variable PARSEABLE_URL
Private URL: http://parseable.railway.internal:8080 (also the variable PARSEABLE_PRIVATE_URL), for services in the same project that ship logs
Credentials: user admin (fixed), password in the variable P_PASSWORD. It stays the same across redeploys.
Auth: HTTP basic auth, -u admin:$P_PASSWORD, on every call under /api/v1/ except the liveness and readiness probes. A call with no credential returns 401.
Health: GET /api/v1/liveness returns 200, no credentials

# run with PARSEABLE_URL and P_PASSWORD set (user: admin)
AUTH="admin:$P_PASSWORD"
curl -s -o /dev/null -w 'health %{http_code}\n' "$PARSEABLE_URL/api/v1/liveness"
curl -s -o /dev/null -w 'no-credential %{http_code}\n' "$PARSEABLE_URL/api/v1/logstream"
curl -s -o /dev/null -w 'create-stream %{http_code}\n' -u "$AUTH" -X PUT "$PARSEABLE_URL/api/v1/logstream/app_logs"
curl -s -o /dev/null -w 'ingest %{http_code}\n' -u "$AUTH" -X POST "$PARSEABLE_URL/api/v1/ingest" \
  -H 'X-P-Stream: app_logs' -H 'Content-Type: application/json' \
  -d '[{"level":"error","message":"disk full","host":"a1"},{"level":"info","message":"started","host":"a2"}]'
# rows become queryable about a minute after ingest, so poll for up to two minutes
for i in $(seq 1 12); do
  START=$(date -u -d '-10 minutes' +%Y-%m-%dT%H:%M:%S.000Z); END=$(date -u -d '+10 minutes' +%Y-%m-%dT%H:%M:%S.000Z)
  RESULT=$(curl -s -u "$AUTH" -X POST "$PARSEABLE_URL/api/v1/query" -H 'Content-Type: application/json' \
    -d "{\"query\":\"select level, message, host from app_logs where level = 'error'\",\"startTime\":\"$START\",\"endTime\":\"$END\"}")
  if [ "$RESULT" != "[]" ]; then break; fi
  sleep 10
done
echo "$RESULT"
echo
curl -s -u "$AUTH" "$PARSEABLE_URL/api/v1/logstream"
echo

A fresh deploy prints health 200, no-credential 401, create-stream 200, ingest 200, then [{"level":"error","message":"disk full","host":"a1"}] from the query (ingested rows are queryable after about a minute, hence the loop; an empty [] early on means not yet, not lost) and a stream list that contains app_logs (and Parseable's own pstats). The time window in a query is required; startTime and endTime are UTC ISO-8601 timestamps. The script uses GNU date; on macOS write the two timestamps by hand.

Why Deploy Parseable on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying Parseable on Railway, you are one step closer to supporting a complete full-stack application with minimal burden. Host your servers, databases, AI agents, and more on Railway.

Agent-ready - generated admin password, a contract block and one working script; no setup wizard.
Logs survive redeploys - state sits on a volume, so streams and their data are there after a restart.
SQL over logs - query with standard SQL instead of learning a log query language.
Light to run - a single Rust binary, no JVM and no separate index cluster.
Pinned image - pinned by digest, so a redeploy never changes the server version underneath you.

Common Use Cases

Application log storage and search - point a logging agent such as Vector, Fluent Bit or Logstash at the ingest endpoint.
Agent and LLM trace logs - an agent writes structured JSON events and queries them back with SQL.
Self-hosted alternative to a hosted log service - keep logs in your own project instead of paying per gigabyte ingested.

Dependencies for Parseable Hosting

Nothing else: staging files and the Parquet store both live on the volume at /data.

Deployment Dependencies

parseablehq/parseable - upstream project
Parseable documentation - ingestion, queries and configuration
bon5co/parseable-railway - the wrapper image used by this template