nano SIEM
Getting Started

Set Up Your First Feed

Supported in:Self-hosted

Add a log source, publish its parser, issue a source-bound ingest token, send events and verify they arrive parsed as OCSF.

Get logs into nano with Ingestion → Log Sources. A log source names a format and the parser that maps it to OCSF; the original event stays available as raw_data. The steps are the same on every deployment: Open, and Self-run on Docker Compose or Kubernetes. Only the ingest address differs.

You need a running deployment (see Install with Docker Compose or Kubernetes), the log_sources:create and log_sources:view permissions to add a source, and log_sources:deploy to publish it. Drafting a parser with pivt needs melod:parser.

1. Find your ingest address

DeploymentHTTP (JSON / NDJSON)HECOTLP/HTTP
Open core (Compose)http(s)://<host>/ingest, or Vector on :8080http://<host>:8088/services/collector/eventhttp(s)://<host>/otlp/v1/{logs,traces,metrics}
Self-run (Compose)Same as open coreSame as open coreSame as open core
Self-run (Kubernetes)https://<ingest-host>/ingesthttps://<ingest-host>/services/collectorhttps://<ingest-host>/otlp/v1/{logs,traces,metrics}

On Kubernetes, senders use a dedicated ingest hostname, such as ingest.example.com, separate from the address you sign in to. A dedicated ingest frontend is coming to Self-run on Docker Compose. The Connect step of Add source shows the exact endpoint for your deployment.

2. Add the source

Choose Ingestion → Log Sources → Add source. The flow has these steps:

  1. Source. Pick a supported source from the catalog, or choose Custom source and enter a lowercase identifier such as acme_app. After parsing, it's stored on each event as metadata.log_source.
  2. Details. Vendor, product and category, which organize the source and give pivt context.
  3. Transport. How events arrive: HEC, HTTP JSON, OTLP, or a Source configuration (Kafka, AWS S3/SQS, GCP Pub/Sub or a listener) that reads them for you. See Integrations.
  4. Connect. The ingest endpoint and the source's credentials.
  5. Sample & parse. For a custom source: Paste samples (pivt drafts the parser), From data (use logs already arriving), or Write VRL yourself.
  6. Review & publish. Save draft to come back later, or Publish source to create the parser and its routing and deploy both to Vector.

For a source in the catalog, the parser comes from the nano parser repository; you can also import parsers in bulk from the Repositories tab. The OCSF catalog covers common sources such as AWS, Azure, GCP, Windows, Sysmon, Palo Alto, CrowdStrike and Okta; see Supported sources.

Draft a custom parser

  1. Paste 5–10 representative events, with one complete event per line. Include different event types, successes and failures. Remove secrets from samples.
  2. Generate the draft with pivt, then review the VRL, validate it and test it against the samples. Confirm the event class and the fields you need. Source fields with no OCSF home go under unmapped.
  3. If your timestamps carry no timezone offset, set the source's timezone so nano converts them to UTC.

A generated draft needs review before you publish it. To change a parser later, edit it on the log source's VRL editor tab and choose Publish again; the Versions tab keeps the history so you can revert. See Parser extensions.

3. Issue an ingest token

Open Ingestion → Log Sources → Credentials, create a named token for your sender and bind it to the source. Token management needs settings:system. The value appears once; copy it into your sender's secret store.

Each token sends to one source, and its binding selects the parser: X-Source-Type and HEC sourcetype don't override it. An unbound token is refused. Don't share one token across several sources. The examples below assume the token is in NANO_INGEST_TOKEN.

4. Send a test event

HTTP JSON (objects, arrays or NDJSON):

curl -X POST "https://<ingest-address>/ingest" \
  -H "Authorization: Bearer $NANO_INGEST_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"message": "hello from curl"}'

HEC:

curl -sS "https://<ingest-address>/services/collector/event" \
  -H "Authorization: Splunk $NANO_INGEST_TOKEN" \
  -H "X-Splunk-Request-Channel: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{"event": {"message": "hello from curl"}}'

The authorization scheme and the channel header in the HEC command are required wire literals. HEC requests need a channel (any UUID): without one, nano answers 400 with Data channel is missing. On open core, HEC is on port 8088 and needs the full /services/collector/event path.

For a real sender, see HEC, OTLP, Vector aggregator, Cribl Stream or the nano-connect client.

5. Verify arrival and parsing

In Search, select the last 15 minutes and replace acme_app with your source:

metadata.log_source="acme_app" | head 10

Then check parsing:

metadata.log_source="acme_app" | stats count by class_name
  • No rows: check the sender's endpoint, protocol and token, and that the token is bound to this source.
  • Base Event or a missing class: delivery works, but the events didn't map to a specific OCSF class. Check the published parser against the raw format in raw_data.
  • Expected class and fields: check fields such as device.hostname, actor.user.name, process.name or src_endpoint.ip against your sample.

A new or changed parser applies to new events only; it doesn't reparse stored events. Send fresh events after publishing.

Troubleshoot

Contact support if these checks don't resolve the problem. Include the deployment, request ID and time with timezone.

SymptomWhat to do
401Check the token, protocol, header scheme and whether the token was revoked.
403Check the token's source binding under Credentials, and any IP allowlist on the source.
400 from HTTP JSONSend valid JSON or NDJSON. Raw text belongs on the HEC raw endpoint.
HEC sender gets 404 on open coreUse port 8088 and the full /services/collector/event path.
Only Base Event or unparsed eventsPublish a matching parser, check the raw format, and send new events.

What's next

On this page