Set Up Your First Feed
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
| Deployment | HTTP (JSON / NDJSON) | HEC | OTLP/HTTP |
|---|---|---|---|
| Open core (Compose) | http(s)://<host>/ingest, or Vector on :8080 | http://<host>:8088/services/collector/event | http(s)://<host>/otlp/v1/{logs,traces,metrics} |
| Self-run (Compose) | Same as open core | Same as open core | Same as open core |
| Self-run (Kubernetes) | https://<ingest-host>/ingest | https://<ingest-host>/services/collector | https://<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:
- 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 asmetadata.log_source. - Details. Vendor, product and category, which organize the source and give pivt context.
- 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.
- Connect. The ingest endpoint and the source's credentials.
- Sample & parse. For a custom source: Paste samples (pivt drafts the parser), From data (use logs already arriving), or Write VRL yourself.
- 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
- Paste 5–10 representative events, with one complete event per line. Include different event types, successes and failures. Remove secrets from samples.
- 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. - 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 10Then 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.nameorsrc_endpoint.ipagainst 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.
| Symptom | What to do |
|---|---|
401 | Check the token, protocol, header scheme and whether the token was revoked. |
403 | Check the token's source binding under Credentials, and any IP allowlist on the source. |
400 from HTTP JSON | Send valid JSON or NDJSON. Raw text belongs on the HEC raw endpoint. |
HEC sender gets 404 on open core | Use port 8088 and the full /services/collector/event path. |
| Only Base Event or unparsed events | Publish a matching parser, check the raw format, and send new events. |