What the Wazuh and Splunk integration changes for your SOC
If your security operations center runs Splunk and Wazuh side by side, or is weighing whether to run them together or move collection from one to the other, this page covers the forwarding approach Wazuh documents for Splunk and the order in which to set it up. The choice affects which alerts analysts see, where they investigate them, and how much data Splunk ingests. This section explains what changes for your analysts, what stays in each platform, and why the work happens entirely inside your own infrastructure.
For analysts, the main change is where alerts first appear and where they are triaged. Wazuh agents on endpoints send events to the Wazuh server, which decodes them and applies rules before alerts are stored in the Wazuh indexer and shown in the Wazuh dashboard. Once forwarding is in place, the same events can also be searched and correlated in Splunk. Your team needs to decide which queue is the working queue for each alert type, because two places showing the same event can cause duplicate tickets and conflicting status. Write that decision down before any analyst is trained on the new flow.
Each platform keeps its own job. Wazuh keeps endpoint collection, decoding, Wazuh rule logic, file integrity and vulnerability data, and its own dashboard views. Splunk keeps the searches, dashboards, retention settings and correlation content your analysts already depend on. Forwarding does not move ownership of either side. Confirm with the Wazuh documentation which data types the documented method sends, which fields arrive in Splunk and whether your current Splunk data model can use them without changes. Those checks decide how much of your existing Splunk content needs rework.
Everything in this work runs inside your infrastructure. The Wazuh components, the Splunk forwarding path, the HTTP Event Collector endpoint and any index settings sit in your cloud accounts, data centers or air-gapped network, and DeployOpen configures them there. Before the build starts, agree who owns the Splunk side, which alert levels are forwarded, how long each platform retains the data and who approves changes to the forwarding configuration. The Wazuh software carries no license fee, so the cost of this integration is mainly the labor, the added infrastructure and the Splunk ingest you choose to pay for.
Prerequisites for the Wazuh and Splunk integration
The integration connects a Wazuh deployment to a Splunk instance. Confirm each prerequisite below against the current Wazuh documentation and the Splunk version in use, and assign a named owner to each before the build starts.
Wazuh release line and patch level
The 4.14 release line is the reference point for this integration. Before the build, confirm the exact 4.14 patch level and check the documented steps against that version. Wazuh publishes 4.14 patch releases roughly every one to two months, so the version can change between planning and cutover. Check the release notes on the day you freeze the version, and record that version in the build plan so every later step refers to the same release.
Wazuh indexer, server and dashboard
The integration depends on three central components: the Wazuh indexer, which stores alerts, the Wazuh server, which decodes and analyzes agent data, and the Wazuh dashboard, which your analysts use. Confirm that all three run on the same release line. Decide whether the server runs as a single node or a cluster, and record which node will hold the forwarding configuration. Agents on endpoints feed the server, so keep their versions in the same inventory.
Splunk version and deployment type
Confirm the Splunk version and deployment type before you choose a forwarding method. Splunk Enterprise on premises, Splunk Cloud and distributed deployments may handle data inputs differently, so check the Splunk documentation for the version in use. Confirm whether your administrators can create indexes, tokens and inputs themselves or need a change request for each one. Those answers decide how much of the setup your team controls directly.
HTTP Event Collector or other receiver
Confirm that HTTP Event Collector is enabled on the Splunk instance, or identify the other receiving path the current Wazuh documentation describes for your version. Record the receiving endpoint, the token owner and the target index before the build starts. Decide which indexes will hold Wazuh alerts and archives, and who may search them. Token scope and index permissions are set on the Splunk side and determine what the forwarder can write.
Network paths and certificates
Map every connection the integration needs: from the Wazuh server or indexer to the Splunk receiving port, and from administrators to the Wazuh dashboard. Confirm firewall rules, proxies and DNS names in both directions before the build. List which certificate authority signs each certificate, who renews it, and whether the Splunk side trusts that chain. Plan how a failed certificate check will appear in logs so the team sees it quickly.
Named owners on both sides
Name one accountable owner for the Wazuh side and one for the Splunk side, plus a backup for each. The Wazuh owner typically covers central components, agent versions and rule changes, while the Splunk owner covers indexes, tokens, storage and search access. Write down who approves token creation, who may change the forwarding configuration, and who receives alerts when the pipeline stops. Settle these roles before the build, since the first end-to-end test needs decisions from both sides.
Wazuh and Splunk integration setup, in order
This sequence takes the integration from a documented design to a verified data path: versions and network access are confirmed, Splunk receives Wazuh data in a dedicated index, Wazuh forwards a test alert, and the event is checked in Splunk. Each step ends with a check, so any failure can be traced to one layer. The Wazuh documentation for the release in use is the source of truth for configuration keys.
Confirm versions and network paths
Start with a written inventory: the Wazuh release in use (the 4.14 line is the current release line, and the release notes list its patch versions), the Splunk version and deployment type, and the path from the Wazuh server to the Splunk receiving port. Your network and security team confirms that firewall rules, DNS names and any TLS certificate trust required by the chosen method are in place. Done when a connectivity test from the Wazuh server to the Splunk endpoint succeeds and both versions are recorded in the change record.
Create the Splunk index and input
A Splunk administrator creates a dedicated index for Wazuh data so retention, access roles and ingest can be managed apart from other sources. For the HTTP Event Collector route, they also create a token bound only to that index and enable the collector if it is off. The team records the index name, token owner and receiving endpoint in the runbook. Done when the index appears in the index list and the token lists only the intended index.
Choose the forwarding method
Select one of the three forwarding methods the Wazuh documentation describes for the release in use, and read its requirements in that documentation before changing anything. The decision usually depends on whether alerts already pass through a collector, whether you need archived events as well as alerts, and which team operates the transport. Write the choice, its owner and the index it targets into the design record. Done when the design is signed off and names the method, the configuration source and the target index.
Configure the Wazuh side
On the Wazuh server, apply the configuration for the chosen method using the exact configuration keys and file locations from the Wazuh documentation for your release. Store the Splunk token in the secret handling your team already uses, not in plain text in shared files. Reload or restart the affected service as the documentation directs, and keep a copy of the prior configuration for rollback. Done when the service runs cleanly and its logs show a successful connection with no authentication errors.
Send a test event
Generate a controlled test event that Wazuh will process as an alert. One option is a benign action on a test agent that matches an existing rule, though the test tooling your Wazuh release documents may be a better fit. Confirm the alert appears in the Wazuh dashboard first, so any gap can be located at the forwarding step. Done when the test alert is visible in the Wazuh dashboard and the forwarder reports it as sent.
Confirm index placement and fields
Search Splunk in the intended index for the test event, using the rule ID or a unique marker in the message. Check that the event lands in the Wazuh index and that the fields your searches and dashboards depend on are extracted with the expected names and values, including agent name, rule level and timestamp. Compare field names with the Wazuh documentation for your release and record any differences. Done when the test alert is found in the intended index with the expected fields, and the search is saved as a baseline for later checks.
Choosing a forwarding method for Splunk
Choose the forwarding method before you configure either platform, because the method decides who owns parsing, how a broken pipeline becomes visible, and what your Splunk team has to keep running afterward. The Wazuh documentation describes more than one way to move data from Wazuh into Splunk. Confirm the current list of methods, their prerequisites and their steps against the Wazuh documentation for the release you run. The 4.14 line has received patches every one to two months, and setup details can change with them. Record the release you tested against in your design document.
For each candidate method, write down what it needs on the Wazuh server: the components to install or enable, the configuration files your team will own, any service account or credentials, the outbound network paths, and whether the change survives a Wazuh upgrade. Then write down what it needs on the Splunk side: the receiving input, the index and sourcetype the data lands in, how tokens or credentials are stored, and any add-on the Splunk team must install and update. Ask your implementation partner or the Wazuh documentation team to walk one sample event through each option, so the field names your searches depend on are checked rather than assumed.
Compare the options on four axes. Operational ownership asks who changes the configuration when a version moves: the Wazuh team, the Splunk team, or both. Parsing location asks whether Wazuh decodes and normalizes events before they reach Splunk, or whether Splunk receives lightly processed data and extracts fields itself. Failure detection asks how you learn that events have stopped: a Wazuh service alert, a Splunk input health view, a drop in the expected alert count, or no built-in signal at all. Maintenance asks what the Splunk team must keep current, such as add-ons, sourcetypes, index retention settings and token rotation.
This page does not name a winner, because the right choice depends on who responds when data stops arriving, how much parsing your Splunk team already owns, and whether Splunk should receive only Wazuh alerts or full archives. As a decision aid only, teams that want one owner for detection logic often test the option where Wazuh does the decoding first and Splunk stores and searches the results. Test that choice against the documented steps for your release and against your own ingest budget before you commit. Run a pilot on a non-production agent group and compare event counts in both platforms. Before sign-off, confirm in writing the method and release you tested, which team is responsible for each side after handover, and which alert fires when the Splunk input stops receiving data.
How Wazuh fields map to Splunk indexes and sourcetypes
This table maps each Wazuh data type to the Splunk index and sourcetype it should land in, along with the group that searches it and the owner who sets its retention. Read each row as a decision to confirm before ingestion starts, because file paths and field names can change between Wazuh releases. Any field marked as unconfirmed must be checked in a test environment on the Wazuh 4.14 release line before production indexing.
| Data type | Wazuh source | Splunk index and sourcetype | Access group and retention owner |
|---|---|---|---|
| Alerts | Alert output from the Wazuh server, including rule and agent fields (confirm output path for your release) | Dedicated alerts index; sourcetype set by your forwarding method (confirm in test) | SOC analysts; security operations lead sets retention |
| Agent inventory | Agent records from the Wazuh API and indexer, covering agent name, status and operating system | Separate inventory index; snapshot sourcetype chosen by your team (confirm) | IT operations and asset owners; asset management owner sets retention |
| Vulnerability findings | Vulnerability detection results that match agent software inventory against CTI or an offline repository | Separate vulnerability index; sourcetype confirmed against the data your forwarder sends | Vulnerability management team; vulnerability management owner sets retention |
| Archived events | Full event archive from the Wazuh server, only if archiving is enabled in your configuration (confirm) | Archive index with a retention period set apart from alerts; sourcetype confirmed in test | Forensics and compliance staff only; records or compliance owner sets retention |
| Key search fields | Fields such as rule identifier, rule level, agent name and decoded data fields (confirm each name in your release) | Field extractions defined in the add-on or props and transforms files (confirm names match) | Analysts who build searches; Splunk administrator owns extraction changes |
Designing HTTP Event Collector tokens and indexes
Give each HTTP Event Collector token one job. A token that sends Wazuh alerts should not also carry agent inventory, file integrity events or test data, because the token is the unit you rotate, revoke and audit. Name each token after the data it carries and the Splunk index it may write to, so someone reading the Splunk audit trail can tell which flow produced an event without opening the Wazuh configuration. Before you create anything, decide which Wazuh outputs will leave the platform and which will stay in the Wazuh indexer. That list sets the number of tokens and indexes. Confirm the HEC port, the token options that current Splunk documentation offers and the default settings for new tokens before you copy any example into a build ticket, since defaults can differ from what your team remembers.
Separate indexes by data class and sensitivity. Security alerts, endpoint inventory and vulnerability findings have different readers and different retention needs, so they belong in different indexes. Authentication events and any data that contains personal information deserve a tighter access list than system health telemetry. Map each index to the analyst groups that need it. A first-line queue may need alerts for a short window, an incident response group may need longer history, and a forensic group may need raw events. Index-level roles in Splunk control who can search each index and who can change its settings, so write the role matrix before the first index exists. Ask your Splunk administrator which role capabilities and index settings your license and edition support.
Put TLS in front of the collector endpoint from the first day. Traffic carries alert content and authentication tokens, so the connection from the Wazuh server to the HEC endpoint should be encrypted. The Wazuh side should validate the certificate chain against a certificate authority your team controls, and verification should stay on in test environments too. Confirm with Splunk documentation how the HEC endpoint is configured for TLS and which certificate formats it accepts. For rotation, issue the replacement token, add it to the Wazuh configuration, confirm that events arrive under the new token, and then revoke the old one. Store tokens in a secrets manager or in a file readable only by the service account that runs Wazuh. Keep them out of version control and shared runbooks, and record each rotation date and owner.
Model ingest for each index before you enable it. Every index that receives Wazuh data adds to the volume counted against your Splunk license, so ask which licensing terms apply to each data type you plan to send and whether they are metered the same way. Estimate volume from a sample taken from a test environment or from the Wazuh indexer, then multiply by the retention window assigned to that index. Those two figures show whether an index is worth its cost. Compare the first weeks of actual ingest with the forecast, and tell the migration team which high-volume sources can be filtered on the Wazuh server before they reach Splunk. Keep the forecast in the design record so that every change to an index or source is reviewed against the same numbers.
Using prebuilt dashboards on both sides
The Wazuh dashboard includes prebuilt views for PCI DSS, GDPR, HIPAA and NIST 800-53. Each view groups alerts by the framework requirement they relate to, so an assessor can see which monitored events support a specific requirement. Treat these views as technical evidence that monitoring is in place, not as proof of compliance. The assessor or auditor decides whether the evidence is sufficient.
- PCI DSS: Show which monitored events relate to requirements for systems in scope, such as log review and file integrity events.
- GDPR: Show security alerts tied to systems that process personal data, so you can demonstrate detection and response activity.
- HIPAA: Show alerts on systems that handle electronic protected health information, mapped to the safeguard areas your organization has adopted.
- NIST 800-53: Show alerts mapped to control families you have selected in your system security plan.
- Retention and export: Confirm which views you can export or schedule, and how long alert data stays in the Wazuh indexer under your retention settings.
Before you give screenshots or exports to an assessor, check that each view matches the rules, decoders and agent coverage in your environment.
The integration may deliver dashboards on the Splunk side, but the set depends on the release you run. Do not plan around a specific dashboard until you have confirmed it in the package or release documentation for your version. The dashboards also depend on the index and sourcetype you configured when you set up the HTTP Event Collector, so verify those first.
- Confirm the package contents: Ask the integration owner for the list of dashboards included in the version you will install, and record it.
- Check the data source: Confirm that each dashboard searches the index and sourcetype you created for Wazuh alerts.
- Check access: Confirm which Splunk roles can view the dashboards and whether they need read access to the Wazuh index.
- Test with a known event: Generate a test alert and confirm it appears in the panels, so you know the searches return data and are not silently empty.
- Review search cost: Dashboards run searches on a schedule or on load, so confirm the expected search load with your Splunk administrator.
Store the dashboard list and the version it applies to in your runbook so that each upgrade can be checked against it.
When security operations uses the Wazuh dashboard and another team builds similar views in Splunk, the two can drift apart. Different filters, severity thresholds and time ranges produce different counts for the same question, and the teams spend time reconciling them. Decide which system answers which question before you build any view.
- Assign ownership: Name the team that maintains each view. Security operations often owns detection and triage views in Wazuh, while Splunk may own cross-source searches if that is your standard.
- Map questions to views: Write down which dashboard answers each recurring question, such as daily triage or quarterly control reporting.
- Share the definitions: Use the same rule IDs, alert levels and group names in both places so that counts match for the same period.
- Review at each upgrade: Check that field names and rule groups still behave as expected after a Wazuh or Splunk upgrade.
- Retire unused views: Remove or hide views that nobody has opened in a set review period, so the remaining views stay trustworthy.
Before you retire any duplicate view, compare alert counts for one full day across both sides and confirm that the numbers match.
Cutting Splunk ingest during a migration with Wazuh
Every data source needs one of three outcomes before the migration plan is final: it stays in Splunk, it moves to Wazuh, or it runs in both platforms during a parallel period. Sort each source into one of those lists before any forwarding is changed. Sources that feed Splunk searches, saved alerts, dashboards or scheduled reports usually stay until those dependents have been rebuilt and tested. Endpoint telemetry that Wazuh already collects through its agents, such as file integrity monitoring events and the software inventory used for vulnerability detection, is a stronger candidate to move. Record the reason for each placement, the owner who agreed to it, and the date it will be reviewed. Measure current ingest before deciding anything. Pull ingest reports from Splunk by source, sourcetype and index over a window long enough to include month-end processing and any seasonal peaks. Ask your Splunk administrators to confirm which reports they use and whether licensing data is reported on the same basis. The estimate of what could be removed from Splunk should come from those reports, not from assumptions or vendor comparisons. For each high-volume source, also note which saved searches, alerts and dashboards read from its index, because volume alone does not show how much work depends on that data.
Turning off a Splunk source removes every correlation rule, alert and report that depends on it, and those dependencies are often undocumented. Map each Splunk alert to the source it reads, then identify the Wazuh decoders and rules that cover the same event types. Where a Wazuh equivalent exists, test it against known events, either replayed from a lab or generated by a controlled test, and confirm the alert reaches the same queue, ticketing integration or responder. Where no equivalent exists, keep the source in Splunk or build and test the Wazuh rule first. Treat any gap in this mapping as a blocker for turning off that source, and record who accepted any residual risk.
A parallel run sends the same events to both platforms, so Splunk ingest can increase during the overlap before it falls. Plan for that increase in the migration budget and in the license conversation with your Splunk account team. Set the length of the dual-run period from written validation criteria, such as a set number of days of matching alert outcomes that your team defines, rather than from a calendar date chosen in advance. Retention is a separate obligation. Check the retention period in your Splunk index settings and confirm with your compliance owner which logs must stay searchable, and for how long, under internal policy or external regulation. Moving a source to Wazuh does not end that obligation, so confirm the retention configuration in the Wazuh indexer before historical data is left behind.
Set approval steps before any forwarding is removed. A typical gate includes sign-off from the data owner, the security operations lead, the compliance owner and the team that manages the Splunk contract. Require documented evidence for each source: the detection mapping is complete, the coverage tests passed, dashboards and reports have been rebuilt, the retention requirement is confirmed, and the owner has accepted any residual risk. Stop forwarding in stages, not all at once, and keep the Splunk index readable for an agreed period after the last event arrives so that investigations can still reach historical data. Record each decision in a change ticket so that the reasoning is available to auditors and to the next person who reviews the placement.
Securing the Wazuh to Splunk data path
These six controls cover the path that carries Wazuh alerts into Splunk: credentials, network hops, stored secrets, index permissions, sign-in and the record of changes. Each one should be checked against your own security baseline before go-live, because the exact settings depend on your identity provider, certificate authority and Splunk deployment.
Least-privilege Splunk tokens and roles
Create a dedicated Splunk account for the Wazuh forwarding path, with a token scoped only to the target index and the HTTP Event Collector input that receives Wazuh data. Grant write permission on that index and nothing else, so a leaked token cannot read other Splunk data. Confirm with your Splunk administrators which role model they use and whether the token can be rotated without downtime on the Wazuh side.
TLS on every hop
Encrypt each connection in the path: agents to the Wazuh server, the Wazuh server to Splunk, and access to the Wazuh indexer and dashboard. HEC endpoints should use HTTPS with certificates issued by your internal certificate authority, and the Wazuh side must trust that authority. Check certificate expiry dates and the protocol versions each component accepts, and record them in your change log before go-live.
Secret storage on the Wazuh server
Tokens, passwords and private keys used by the integration should sit in a managed secret store or in a file readable only by the service account that runs the forwarder. Limit who can read Wazuh server backups, since those copies can expose the same credentials. Confirm in the Wazuh documentation which configuration files hold credentials, and plan how a token rotation updates each of them.
Index access controls in Splunk
Set who can search the Wazuh index through Splunk roles, separate from who can administer inputs. Security analysts may need search access, while the forwarding account needs only ingest. Review read permissions on the index against your data classification, because Wazuh alerts can contain usernames, hostnames and file paths. Confirm the index retention settings as part of the same review.
Single sign-on on both sides
Wazuh supports SAML single sign-on alongside its internal user database, with documented guides for several identity providers, including Okta, Microsoft Entra ID, Keycloak and authentik. Configure Splunk authentication against the same identity source, so disabling one account removes access in both consoles. Test group-to-role mapping on both sides before enabling it for all analysts, and document the local break-glass account your policy requires.
Audit logging of configuration changes
Record who changes the integration: edits to Wazuh server configuration, Splunk input changes, token creation and rotation, and role assignments. Decide where these logs are stored, how long they are kept, and who reviews them. Confirm which configuration changes each platform logs by default and which need additional auditing enabled in your environment.
Common Wazuh and Splunk integration failures and fixes
This table pairs common Wazuh to Splunk integration failures with their likely causes, fixes and the first check to run. Work through the first check before changing configuration, since most symptoms trace back to the forwarder, the HTTP Event Collector token or the index and sourcetype settings. Confirm exact error text against the Wazuh and Splunk releases in your environment.
| Symptom | Likely cause | Fix | Check first |
|---|---|---|---|
| No events in expected index | Wrong index name, token not allowed to write to that index, or the forwarder is not sending | Correct the index in the forwarder output and confirm the token's allowed indexes include it | Search recent events in the index, then check Splunk internal logs for HEC errors |
| Events arrive with unparsed fields | Sourcetype not set, or not the one the Wazuh integration documents for its JSON fields | Set the documented sourcetype and apply the matching field extraction settings, then re-ingest a test event | Compare the sourcetype of a raw event with the value the documentation expects |
| Token rejected or expired | HEC token disabled, deleted or copied incorrectly, or the authorization header format is wrong | Re-enable or recreate the token, update the stored value and correct the header format | Send a test event to the collector and read the HTTP status code and message returned |
| TLS trust errors | Splunk certificate not trusted by the Wazuh host, or the certificate name does not match the host name used | Install the internal certificate authority on the sending host or issue a certificate matching the collector name | Test the TLS handshake to the collector port and review the certificate chain presented |
| Duplicate events after a retry | Sender retries after a timeout that had already succeeded, or two forwarding paths run at the same time | Run one forwarding path only and use a stable event identifier to deduplicate where your release supports it | Count events for a single alert ID across the index and compare with the alert count in Wazuh |
| Ingest higher than planned | Low-severity alerts or archive data forwarded, or broad rules sending every event | Filter by alert level, rule group or agent before forwarding and confirm the scope with the security team | Measure daily volume by rule ID and sourcetype in Splunk |
| Dashboards show empty panels | Index, field names or time range in dashboard searches do not match the ingested data | Update the panel searches to the current index and field names and widen the time range | Run one panel's search in the search bar using the same time range |
| Test events never reach Splunk | Firewall blocks the collector port, or the sending host cannot resolve the collector name | Open the port between sender and collector and correct DNS or host entries | Check network connectivity from the Wazuh host to the collector endpoint |
What a Wazuh and Splunk integration costs and who does the work
Does self-hosted Wazuh carry a license fee for this integration?
No. The self-hosted Wazuh software is open source and distributed under the GNU General Public License version 2, with an exception for linking with OpenSSL, so there is no per-license charge for the Wazuh components. The cost moves elsewhere: infrastructure for the Wazuh indexer, server and dashboard, Splunk licensing and ingest (Splunk bills on the data you send it, under your own contract), and labor to design, build and test the forwarding path. Splunk is the line item buyers most often underestimate, so confirm your license model and ingest terms with your Splunk account team before sizing anything. Wazuh Cloud is a separate managed service with its own tiers, which is a different decision from running the software in your own environment.
What drives the cost of a Wazuh and Splunk integration?
The main drivers are the number of log sources, the index design in Splunk, the migration scope and the compliance evidence the work must produce. Each source adds parsing, decoder and rule checks, field mapping and test cases, so the labor grows with the source count. Index design sets retention, access control and ingest patterns, which affects both build effort and Splunk cost. Migration scope matters most: adding Wazuh alerts alongside existing Splunk content is a smaller job than moving existing searches, dashboards and alerts. Compliance needs add mapping work and documented test results. Ask for a written scope that lists each source, index, dashboard, test and exclusion, because the scope is what the quote follows from.
How long does a Wazuh and Splunk integration take to deliver?
Duration depends on the same drivers as cost, and it also depends on access and approvals in your environment. Work usually moves through environment access, HTTP Event Collector and index setup, a forwarding test on one source, dashboard validation, and handover. Waiting on Splunk administrator access, network paths between the Wazuh server and Splunk, and change windows often adds more time than the build itself. DeployOpen does not publish timelines, because most engagements are fixed-scope and the schedule is agreed in writing from the scope. Ask for milestones with named dependencies, and ask which of them your team must clear before the build starts.
What must our team provide before an integration partner starts work?
Your team needs to provide the access and decisions that the work cannot proceed without. Plan to supply:
- Administrator access to the Wazuh deployment and to Splunk in a non-production environment first
- A named Splunk owner who can approve index names, retention and HEC token handling
- Network paths from the Wazuh server to the Splunk HEC endpoint, and firewall change approval
- A list of log sources with their owners and sample events where available
- Your change approval process and any compliance requirements the output must support
- Test windows and an agreed acceptance method
Missing items usually show up as delays in the first week, so confirm this list during scoping.
Can our internal team build the Wazuh and Splunk integration themselves?
Yes, if the team has working knowledge of Splunk administration, Linux, and operating a Wazuh server and its rules, and if it has time for testing and long-term ownership. The hard parts are usually sizing ingest, avoiding duplicate events, validating field mapping, setting index permissions correctly and keeping changes under control. An internal team keeps full knowledge of the setup, while an outside partner shortens the design and testing phase and brings a documented test method. A practical middle path is to build one source end to end, measure the ingest and field results, and then decide how much of the remaining work to keep in-house. Whichever route you choose, agree on who maintains rules and dashboards after go-live.
Who owns the Splunk licensing and ingest decisions after go-live?
Your organization owns them, because the Splunk contract, the index retention choices and the data volume sent to Splunk are your decisions. Confirm with Splunk which usage measure applies to your contract before go-live, since terms vary by agreement. Costs recur in several places: Splunk licensing or ingest, Wazuh infrastructure, storage for retained data, and maintenance of rules and dashboards. One-time costs are the design, build, testing and handover documentation. Ask any partner to label each line in the quote as one-time or recurring, and to state who carries each recurring item after handover. Ongoing support and upgrades can be covered by a retainer if you want an outside team to keep the integration current.
What should a written scope for this integration include?
A useful written scope names what is in and out, so the quote and the timeline have a clear basis. Ask for:
- The Wazuh version and release line in your environment, and the Splunk version in use
- The list of log sources and the forwarding method chosen for each
- The HTTP Event Collector and index design, including retention and access
- Which prebuilt dashboards are included, and which content is migrated from existing Splunk searches
- The compliance evidence the output must support, stated as technical records rather than audit conclusions
- The test plan, acceptance criteria and responsibilities split between your team and the partner
- Milestones, exclusions and handover, plus any support or retainer option
An auditor or certification body decides whether evidence is sufficient, so the scope should describe what is delivered, not what it will achieve.
How DeployOpen scopes and delivers the Wazuh and Splunk integration
DeployOpen plans, implements, integrates, documents and supports Wazuh and Splunk integration inside your own infrastructure. Engagements are fixed-scope, and the written scope names the forwarding method, Splunk indexes and dashboards before any build begins. The handover pack records configuration, ingest decisions and operating steps so your team can run the integration after go-live.
How we scope
- The written scope names which Wazuh alert data goes to Splunk and which Splunk indexes receive it.
- We confirm the forwarding method against your Wazuh and Splunk versions and network paths before the quote is issued.
- Ongoing tuning, upgrades and monitoring can be covered by a separate retainer agreed in writing.
How we build
- Components are deployed in your infrastructure, with the forwarding path configured and tested end to end.
- Splunk HTTP Event Collector tokens, index permissions and sourcetype mappings are set according to the agreed design.
- Prebuilt dashboards are installed and checked against sample alerts, with changes recorded for your change control.
How we hand over
- Handover documents the forwarding method chosen, token and index settings, and the reasons behind each decision.
- Your team receives runbooks for checking ingest volume, rotating HEC tokens and reviewing dropped or delayed events.
- Ingest reduction decisions are recorded, so Splunk licensing or migration reviews can trace which data moved to Wazuh.
How we support
- Support after go-live is available as a retainer covering patching, version checks and configuration changes.
- Wazuh release changes are reviewed before upgrades, since forwarding behavior may change between patch releases.
- Security testing of the integration path can be scoped separately if your assessors or policies require it.

