This is the fast path. By the end you will have live telemetry flowing, a search you can run, a monitor watching something that matters, security detections turned on, and — if anything fires — an incident the AI analyst has already investigated. No long onboarding, no professional services. Just the shortest route from nothing to a platform that is genuinely watching your systems.
You need an account and a token. That is the entire prerequisite list, and both take under a minute.
Create your organisation at the registration link — no credit card, and the free tier is real enough to do everything in this guide. An organisation is your isolated tenant: your data, your team, your settings, walled off from everyone else's. The first person in becomes the owner, which is the role that controls billing, team membership, and the most sensitive settings; you can invite teammates and assign lighter roles later.
Then mint a token under Settings → API tokens. Tokens are how anything — an application, a script, an agent, a curl command — authenticates to the platform, and they are scoped, so each one can do only what you grant it. For this quickstart an ingest-capable token is all you need. Get into the habit now of giving every token the narrowest scope that lets it do its job; it is the single most important security habit on the platform and it costs nothing to start right. Copy the token somewhere safe when it is created — you will paste it into the commands below.
With those two things in hand, the rest of this is just pointing telemetry at an endpoint and clicking a few times. Let's go.
Pick whichever path matches where you are. All three land data you can search within seconds; you do not need more than one to continue.
This is the fastest path and the one we recommend if it applies. If your applications or your OpenTelemetry collector already export telemetry, you do not change a line of code — you change a destination. Set two environment variables and restart the exporter:
export OTEL_EXPORTER_OTLP_ENDPOINT="https://api.24observe.com/api/v1/otlp" export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer obs_<your_token>"
Logs, metrics, and traces that were going elsewhere now also arrive here, attributed and searchable. If you run the OpenTelemetry collector, this is a one-line change to a destination in its config, and the collector is the supported bridge for gRPC exporters. Within a few seconds your first spans and logs appear in Explore.
To get a whole Linux host shipping its logs and metrics, generate an install command in the dashboard under Settings → Linux Hosts and run the one-liner on the box as root:
curl -sSL https://api.24observe.com/install.sh | sudo bash -s -- --enroll-token=<TOKEN>
The Sensor installs from a signed package, self-enrolls with a per-host token, turns on edge redaction so secrets never leave the machine, and starts shipping system logs and host metrics. In under a minute the host appears in your fleet and its logs show up in Explore. This is the right path when the thing you want to observe is a server rather than an instrumented application.
If you only want to confirm everything is wired correctly, a single HTTP request lands an event you can immediately search:
curl -X POST https://api.24observe.com/api/v1/logs \
-H "Authorization: Bearer obs_<your_token>" \
-H "Content-Type: application/json" \
-d '[{"level":"info","service":"checkout","message":"order placed","order_id":"A1842"}]' The endpoint accepts a JSON array of events, normalises common fields, and returns quickly. Send that, and you have one searchable log line — enough to do Step 2. Real sources (firewalls, cloud platforms, edge networks) push to the same kind of endpoint, so proving it with one curl also proves the path your production sources will take.
Open Explore and confirm your data is really there — then learn the one skill that pays off everywhere on the platform.
Open Explore (or Logs) in the dashboard. Your events should be there; if the view looks empty, widen the time range, because a narrow default window is the most common reason new data appears to be missing. Once you see your events, you have proven the whole ingest path end to end — which is the milestone that matters, because everything else builds on data actually arriving.
Now try a filter. Search uses a readable query language you can pick up by example: filter by a field, match text, narrow by level. Type the service name you sent, or filter to level:error, and watch the results narrow. The important thing to internalise is that this same query language is used everywhere — the filter you just wrote is the same syntax that will back a saved chart, an alert, and a detection rule. Learn it once here, and the skill compounds across the rest of the platform.
If you want to watch events arrive in real time — useful when you are actively shipping a change — switch on live tail, which follows a filtered stream as it happens using the same syntax. Between historical search and live tail you can answer almost any "what is happening / what happened" question, and you now know how to do both. That is Step 2 done.
Data you can search is useful; data that watches itself is the point. Two quick setups give you reliability and security coverage.
Under Monitors, add a check on something that must stay up — a URL, a port, a certificate. Use a content check, not just a status check, so a page that returns 200 but renders the wrong thing still trips. Uptime →
Under detections, turn on the packs relevant to your data. They are telemetry-gated, so they stay quiet until the events they watch for arrive, then begin matching automatically. SIEM →
Wire up at least one channel — chat, email, SMS — so incidents actually reach you. Route by severity so an emergency rings a phone and routine signals go somewhere quiet. Alerting →
If you sent metrics, add a threshold alert on the series that matters — CPU, latency, free disk — so a breach opens an incident, not just a chart nobody is watching. Metrics →
The reason this trio matters is that it closes the loop from signal to notification. A monitor tells you when something breaks; a detection pack watches for threats and failures in your telemetry; an alert channel makes sure a human hears about it. With those three in place you have gone from "a place my data sits" to "a platform that is actively watching my systems and will tell me when something is wrong" — which is the whole reason to be here. Everything beyond this is depth, not prerequisite.
This is the payoff, and it requires nothing extra from you. When something fires, the investigation is already underway.
Here is what makes the platform different from a place that merely stores and alerts. When a monitor fails, a metric breaches, or a detection matches, it opens a first-class incident — and the AI analyst immediately goes to work on it. It gathers the related events, traces what the incident touches, corroborates against threat intelligence where relevant, and attaches a root-cause verdict with the supporting evidence cited. You do not have to start this; it starts itself.
So the first time an incident opens in your new setup, open it and notice what is already there: not a bare alert and a link, but a conclusion you can read and verify. The recommended next action — block a source, roll back a deploy, force a password reset — is proposed for you to approve, never executed automatically, so you stay in control while the laborious gathering is done for you. This is the moment the ten minutes pays off: you went from sign-up to being handed investigated incidents, not raw alerts.
From here, the natural next steps are to invite your team and set up on-call so incidents reach the right person, publish a status page so customers stay informed, and let the context graph build a live map of what depends on what. None of those are required to get value — you already have it — but each one deepens the platform's usefulness, and each is a few clicks away now that the foundation is flowing. When you are ready, the user guide walks through the day-to-day, and the admin guide covers roles, tokens, and governance for a growing team.
It is worth pausing on how much ground those ten minutes covered, because it is more than it feels like in the moment. You stood up an isolated tenant, established authenticated ingest over open standards, proved the pipeline end to end, learned the one query language that runs through the whole platform, put a check on something that matters, turned on real security coverage, wired a notification path, and saw an incident arrive already investigated. In most stacks, each of those is a separate tool, a separate integration, and a separate afternoon. Here they are one short setup, because the platform was built to be adopted in exactly this order.
That ordering is deliberate, and it is the same order we would suggest you keep growing in. Get one slice genuinely trustworthy — the service that matters most, its logs, a monitor, a detection pack or two — before you widen, because a handful of signals you believe is worth more than a hundred you have learned to ignore. Then add the next slice the same way, and let coverage accumulate as your confidence does. The platform does not punish incremental adoption; it rewards it, which is why starting small and widening deliberately beats trying to switch everything on at once.
Authorization: Bearer header.Create your account, send your first events, turn on a monitor and the detection packs, and let the analyst investigate whatever fires. The fastest path from nothing to genuinely covered.