PrairieLog API
Real-time error alerts for indie apps
Receive smart alerts to Slack or Discord webhooks when your indie apps runs into issues. No log storage.
PrairieLog API
Receive smart alerts to Slack or Discord webhooks when your indie apps runs into issues. No log storage.
Get to know more about PrairieLog
Run a quick live demo with your own webhook to get a test alert
Sign in to manage your apps, ingestion tokens, and destinations
SDK installs, framework examples, and the API usage flow
Browse endpoints from the embedded OpenAPI contract
Answers to common questions before wiring into your app
After registering with an account, you can create an application object and personal token. You can then use your token and slack/discord webhook URLs to communicate with PrairieLog via endpoints. For PrairieLog API to send alerts, it must be sent ERROR logs through the Kafka-backed ingestion endpoints (what the SDKs use by default) — plain log-relay endpoints never alert, no matter the level. Once a queued ERROR log is picked up, PrairieLog gathers nearby related INFO, DEBUG, and TRACE logs asynchronously to analyze and create alerts. Only ERROR events trigger this process and other log levels stay quiet in the meantime. PrairieLog uses a number of data techniques to group, condense, and summarize related logs, then uses a model for final smart alert creation to send to your configured application webhooks.
SDKs are configured to provide the shortest path for devs to integrate PrairieLog into their application. Currently, they serve as a wrapper around the raw API calls, they do not substitute the API so you still need a valid web connection. SDKs send batched logs through the Kafka-backed ingestion endpoints, where matching ERROR logs are grouped and sent to an AI model for analysis, falling back to regular summarized alerting if analysis fails. Optionally you can use the raw API docs to send logs directly using /api/v1/kafka/log-events for single events OR /api/v1/kafka/log-events/batch for up to 100 logging events in a single request, if you want that same alerting behavior yourself. The plain /api/v1/log-events and /api/v1/log-events/batch endpoints are also available for simple relay-only logging, but they never trigger alerts. You are free to use whatever makes sense for your use case as long you provide a webhook and access token.
Put ingestion tokens in server-controlled configuration such as environment variables. Do not commit them to git. Treat Slack and Discord webhook URLs like passwords too: once configured, the dashboard should not need to show the full URL again. Browser logging is possible only with a token you are comfortable exposing and revoking.
No. PrairieLog is intentionally a relay, not a log warehouse. It keeps enough in memory to group and deliver alerts, then discards events. The only time your logs might be read by PrairieLog outside of sending alerts is for debugging production issues - if they are still present. If you need retention, search, dashboards, or compliance archives, pair PrairieLog with a storage-focused logging tool.
Use the live demo to confirm your Slack or Discord webhook works and to see the request flow. The dashboard serves as a more extensive demo where you can create an app, generate an ingestion token, add alert destinations, then copy the SDK snippet into your service. It's best to use a token generated from from a terminal to send logs from a production app, the frontend UI is a good way to test the flow and see how PrairieLog works.
It is not a full APM, metrics backend, distributed trace system, or searchable log archive. PrairieLog is best when the immediate need is simpler: send structured ERROR events from a small app and get a useful alert in chat when something breaks.
From a webhook URL to a quiet, grouped alert in four steps.
Your Slack or Discord webhook URL — where you want PrairieLog to send alerts.
A secret your app uses to send logs to PrairieLog. It is shown once at creation — store it in a server environment variable.
Install the TypeScript, Python, or Logback SDK, or POST JSON logs to the Kafka-backed batch ingestion endpoint with the X-Ingestion-Token header.
Matching ERROR logs are aggregated asynchronously, then delivered to your alert webhook. Other levels are accepted but stay quiet, and the plain (non-Kafka) log endpoints never alert.
Your app or service sends ERROR logs to PrairieLog; PrairieLog forwards aggregated alerts/messages to the Slack or Discord webhook you configure.
npm install @prairielog/client
pip install prairielog-handler
<dependency>
<groupId>io.github.robertsima</groupId>
<artifactId>prairielog-logback</artifactId>
<version>0.2.0</version>
</dependency>import { PrairieLogClient } from "@prairielog/client";
const prairieLog = new PrairieLogClient({
apiUrl: "__API_BASE_URL__",
ingestionToken: process.env.PRAIRIELOG_INGESTION_TOKEN,
defaultLogger: "my-app",
batchSize: 50
});
prairieLog.installNodeHandlers();
// await prairieLog.captureException(new Error("Payment failed for user 123"));Fastest path: run the live demo — no sign-in needed — to test your alert webhook. Set up a real project later from the dashboard.