24observe
checking… Start free
Docs · Quickstart

Sign-up to an investigated incident, in about ten minutes.

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.

1. Send data 2. Search it 3. Monitor + detect 4. Get the verdict
app.24observe.com/explore
First events landed
checkout · live
order placed · order_id=A1842
service:checkoutjust now
INFO
monitor: shop.example.com — up
content check60s interval
UP
detections enabled · 14 packs
telemetry-gatedwatching
ON
Ten minutes from sign-up to a platform that’s watching
Before you start

Two things, and then we move.

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.

Step 1

Send your first data.

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.

Option A — you already emit OpenTelemetry

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.

Option B — you want a server reporting

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.

Option C — you just want to prove the pipeline

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.

Step 2

Search what you just sent.

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.

Step 3

Monitor something, and turn on detections.

Data you can search is useful; data that watches itself is the point. Two quick setups give you reliability and security coverage.

Create a monitor

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 →

Enable detection packs

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 →

Add an alert channel

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 →

Set a metric threshold (optional)

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.

Step 4

Let the analyst do the first hour for you.

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.

What you’ve actually accomplished

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.

If something’s off

Quick troubleshooting.

No data appears
Widen the time range first — a narrow window hides recent events. Then confirm the token has ingest scope and the endpoint URL is exact.
401 / auth error
The token is wrong, expired, or lacks scope. Mint a fresh one under Settings → API tokens and check the Authorization: Bearer header.
Body rejected
The logs endpoint returns a clear error for malformed or oversized JSON. Validate the payload is a well-formed array and retry.
Sensor not reporting
Re-run the install command (it rotates the host token), and check the host has outbound network to the API endpoint.
Detections quiet
That is usually correct — they are telemetry-gated and stay silent until matching events arrive. Send relevant data to see them fire.
No alert received
Confirm an alert channel is configured and the routing covers the incident's severity. A channel with no route delivers nothing.
Questions, answered

Quickstart — FAQ.

Do I need a credit card to start?
No. The free tier needs no card and is genuinely usable — you can send real data, run searches, turn on detections, and see the analyst work. Create an organisation, mint a token, and send your first events; you will be looking at live data within a few minutes. Upgrade only when your volume or team outgrows the free plan.
What is the fastest way to get data in?
If your stack already emits OpenTelemetry, the fastest path is to point your existing exporter at our OTLP endpoint with two environment variables — no code change. If you want a server reporting, the one-line Linux Sensor ships logs and host metrics in under a minute. If you just want to prove the pipeline, a single curl to the logs endpoint lands an event you can search immediately.
Where do I get a token?
In the dashboard under Settings → API tokens. Create a token scoped to what you need — for sending telemetry, an ingest-capable token is enough; for managing monitors or detections from scripts, add the relevant write scopes. Least privilege is the right habit from the first token: give each token only the scopes its job requires.
How soon will detections start working?
As soon as relevant telemetry arrives. The detection packs are telemetry-gated, so they begin matching the moment the events they watch for show up — authentication logs light up the access packs, for example. You enable a pack with one action, and from then on any match opens an incident the analyst investigates. There is no waiting period or training phase.
What should I set up first after data is flowing?
A monitor on the thing you most need to stay up, a detection pack or two for security coverage, and an alert channel so you actually hear about incidents. That trio — know when it breaks, watch for threats, get notified — is the core loop. On-call, status pages, and the context graph are valuable next steps once the basics are flowing.
Can I do all of this from the API instead of the dashboard?
Yes. Every step here has an API equivalent, and the platform is designed to be driven by scripts and agents as readily as by humans. If you would rather provision monitors, detections, and alerts as code, see the API reference and the agent cookbook — you can encode your whole setup in a pipeline.
I sent data but I don’t see it — what now?
Check three things: the token is valid and has ingest scope, the endpoint is exactly the OTLP or logs URL shown here, and the payload is well-formed JSON. The logs endpoint returns a clear error code for malformed or oversized bodies. If events were accepted but are not visible, widen your search time range and confirm the service or level filter is not excluding them. Most first-time issues are a wrong token scope or a too-narrow search window.

Ten minutes. Then it’s watching for you.

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.