How to set up MISP threat intelligence feeds without flooding your instance
MISP feeds are set up per source, and each feed needs a deliberate choice of caching for lookups, correlation or import as events. A new instance usually ships with a catalog of default feeds, and enabling them all at once is the fastest way to lose control of what the instance holds. Teams need this work when they add a feed for the first time, when a feed produces more volume than anyone expected, or when analysts ask why a lookup returns a hit from a source nobody remembers approving. Setting the rule before the first pull is far easier than cleaning up events afterward.
Importing every feed as events by default creates problems that are hard to reverse. Each feed's indicators become events that analysts must triage, tag and eventually retire, so the event list grows with whatever the least selective source publishes. Correlation then matches new attributes against a large pool of low-value data, which produces more hits for analysts to review. If the instance synchronizes with partners or publishes downstream, feed data can leave the organization under distribution settings nobody chose for it. Removing a feed later means finding and deleting every event it created, which takes longer than deciding the right mode at the start.
For each feed, start from the use it serves. A lookup cache suits data analysts should be able to check during an investigation without storing it as an event. Correlation suits data that should match attributes your team already holds, so hits surface without bulk storage. Import as events suits data your team will review, tag, distribute or act on. Before choosing, confirm the feed's terms of use, its update frequency, the format it arrives in, and whether it carries a distribution or TLP marking you must preserve. Record the owner and the reason for each setting in a feed register, because that reasoning is what you will need when a feed misbehaves.
Plan the rollout in small steps. Enable one feed in the mode you chose, watch its volume and hit quality over a review period you set in advance, and only then enable the next. Confirm the exact names and options of these settings in the feed configuration of the version you deploy, since interface labels and defaults can change between releases. MISP 2.5 is the recommended version for new deployments, and MISP 2.4 is end of life, so build the register against the version you will run. Ongoing effort comes from reviewing the register, retiring stale feeds and checking that upstream formats still parse correctly.
Cache, correlate or import: choosing the feed mode for each source
This table compares the three per-feed decisions in MISP, caching for lookups, correlating against existing data and importing as events, against the goal each serves, the data volume and noise it adds and its ongoing operational cost. Read each row as a separate switch: the right combination is set feed by feed, and a feed can be enabled for one purpose without the others. Exact setting names should be confirmed in the MISP version your team runs.
| Decision | Goal it serves | Data volume and noise | Operational cost |
|---|---|---|---|
| Cache for lookups | Keeps indicators from the feed available for on-demand lookups and enrichment without creating events | Low: indicators are held for lookup only and do not appear in the event list | Low: mainly storage and a feed fetch schedule, with occasional checks that caching is still enabled after upgrades |
| Correlate against existing data | Links feed indicators to attributes already in your events so overlaps surface as correlations | Moderate: matches depend on your existing data, and broad feeds can produce many correlations on common values | Moderate: correlation processing grows with feed size and event count, and matches need triage by an analyst |
| Import as events | Brings feed content in as full events that your team can search, tag, share and act on | High: every imported item adds events and attributes, which can flood the instance with low-value data if the feed is broad | High: ongoing review, tagging, publishing decisions, retention and cleanup of imported events |
| Warning list or filtering first | Reduces false positives before feed data is used for correlation or import | Lowers noise when lists are maintained, but only for values they cover | Moderate: someone must own list updates and check that legitimate indicators are not suppressed |
| Feed purpose in your program | Defines whether the feed serves detection, enrichment, situational awareness or community sharing | Depends on feed scope, format and update frequency, which vary by source | Set during feed selection; a clear purpose keeps the other two decisions consistent |
| Mixed use of one feed | Lets one source be cached for lookups while being correlated for a narrower set of value types | Lower than importing everything, provided the enabled purposes are chosen deliberately | Each enabled purpose adds its own review and monitoring work, so enable only what has an owner |
Choosing from the default MISP feed catalog
MISP ships with a catalog of default intelligence feeds, and the catalog is a starting point for discussion, not a list to switch on. Enabling every feed because it is available fills the instance with data that nobody has reviewed, and the cost shows up later as noise in correlation, duplicate indicators in detection tools and analysts who stop trusting what they see. The right first step is to decide which feeds match the organization's sectors, the tools that will consume the output, the sharing rules that apply to the data and the people who will act on it. Triage each candidate feed against four questions. First, does its subject matter fit your sectors and geographies, so that a feed about threats to a different industry does not generate alerts your team cannot act on? Second, which detection tools will use the output, and does your SIEM, firewall or DNS filtering accept the indicator types the feed produces, such as domains, IP addresses, file hashes or URLs? Third, what sharing rules apply: the feed's TLP marking, any restriction on republishing it to a sharing community and whether your own distribution settings can carry it without widening access. Fourth, who will review the results. A feed that produces hundreds of events a week needs a named analyst or an automated workflow to triage it, and if neither exists the feed should wait. Before enabling a feed, ask its owner four things and record the answers in writing. Ask how often the feed updates and whether updates are full snapshots or incremental changes, since that determines how you schedule pulls and how you expire old data. Ask which format it publishes in, such as the MISP format, STIX, CSV or freetext, because that affects whether MISP imports it as events, caches it for lookups or needs a custom parser. Ask about licensing and permitted use, including whether you may store, correlate and redistribute the data internally and to partners. Ask for the expected volume of indicators per update and how many of them are expected to expire. These answers must come from the feed provider, and the team should check them against its own review: confirm the volume with a trial pull, measure the false positive rate with the analysts who will work the output and confirm that the license covers how your team actually uses the data. Some default feeds will be useful only as lookup sources, and others may justify full event import. Decide that per feed after the triage, not from the catalog defaults. A feed that is enabled but never reviewed is a liability: it adds storage, correlation load and alert volume without adding a decision your team can make. Document the reason for each enabled feed, the owner who reviews it and the condition under which it will be disabled, so the catalog stays a deliberate selection as the organization changes.
Adding a CSV or freetext feed to MISP
This sequence adds a custom CSV or freetext feed to a MISP instance without flooding it with low-value data. It starts from the source file, then sets the default event values and the per-feed behavior, and ends with a reviewed sample of the attributes and tags the feed produces. Each step closes with a check you can record before the feed reaches production.
Confirm the source format and field mapping
Open a sample of the source file and record its delimiter, header row, the column that holds the indicator value, and any column that carries a type, such as an IP address or domain. For freetext sources, note the pattern that separates one indicator from the next and any comment or noise lines. Map each column to a MISP attribute type and category before you change the instance. Done means the mapping is written down and a second person has checked it against the source. Confirm the exact parser options your MISP version offers in the official documentation, because field labels can change between releases.
Set default event information and distribution
In the feed settings, enter a default event information string that names the source and its purpose, so analysts can tell feed events apart. Choose a default distribution level that matches the source's license terms and your sharing rules, and add a TLP tag where the source requires one. Keep distribution narrow until the feed has been reviewed. Check that the feed form shows the values you entered, and that a test record built from the mapping carries the intended distribution and tags instead of the instance defaults.
Add and enable the feed in a test instance
Create the feed in a non-production MISP instance and enable it there first. Keep the feed disabled on production until the remaining steps are complete. Run the test instance on the same MISP version as production so that parser behavior matches. Done means the feed appears in the feed list with the name, URL or local path, and format you entered, and the enabled state is set only on the test instance. Record the MISP version and the feed identifier so the production configuration can be matched later.
Choose the cache, correlate or import setting
Decide what MISP should do with this feed's data. Caching for lookups keeps indicators available for hit checks without creating events. Correlation links new attributes to existing events, which suits sources you already trust for high-value matches. Importing as events creates full events that analysts must triage and that may be shared onward. For bulk or low-confidence lists, lookup-only caching is generally the lower-noise choice. Check that the chosen setting is written next to the feed name with a reason, and that no option is enabled by default that you did not intend.
Run a manual fetch and confirm completion
Trigger a fetch of the feed manually from the feed list instead of waiting for scheduled runs. Watch the job output or feed log until it reports completion. Check that the fetch finishes without parser errors, that the number of records processed matches the number of data rows in your sample, and that any skipped lines are explainable, such as headers, comments or blank rows. If the counts differ, stop and return to the mapping from the first step before going further.
Review attributes, tags and unexpected events
Open a sample of the resulting attributes and compare each one against its source row. Check that attribute types match the source columns, that values were not truncated, and that no value was stored under the wrong type, such as an IP address recorded as a domain. Confirm that tags and event information match your defaults. Then review the event list for events you did not expect. Done means the sample matches the mapping, no unexpected events were created, and any fixes are recorded before the feed is considered ready.
Apply the reviewed configuration to production
Recreate the reviewed feed on the production instance using the settings recorded in the test instance, including the name, format, mapping, default event values, distribution and cache, correlate or import choice. Enable the feed only after the configuration matches the record. Check that the production feed settings match the test record field by field, then run one manual fetch and repeat the attribute and event review from the previous step on a small sample. Keep the test record with the change ticket for later audit.
Security considerations when pulling external feeds
External feeds bring indicators into your MISP instance and, from there, into the tools that act on them. The cards below cover what can go wrong with that data, who may change feed configuration, and how to keep feeds running and correctly shared over time.
Poisoned and malformed entries
A feed can contain indicators that are wrong, malformed, or deliberately misleading, such as benign domains or hashes that will trigger false blocks. Before enabling a new source, import a sample into a test instance and review attribute types, value formats and volume. Decide whether each feed is cached for lookups, correlated, or imported as events, since the choice determines how much unreviewed data reaches your analysts.
Licensing limits on internal reuse
Each feed carries its own terms, and some restrict internal reuse, redistribution, or commercial use even when the data is free to download. Record the license for every source before enabling it, and confirm with the provider whether your intended use, including sharing with partners through MISP, is permitted. Treat this as a legal review item, not a configuration setting.
Restricting who can add or edit feeds
Feed definitions control what data enters the platform, so changing a URL, format or parser is a security-relevant action. Limit feed management to a small set of administrators through MISP roles, and log every change to a feed's URL, enabled state or import settings. Review that list when staff change roles or leave the team.
Effect on detection tool output
Imported attributes and events can flow to downstream consumers through exports, synchronization and APIs, and detection tools may act on them automatically. Confirm which feeds are published or synchronized, and which distribution levels apply, before connecting any exporter to a blocking control. Keep feed-derived attributes separate from analyst-verified intelligence where your tooling cannot tell them apart.
Monitoring failed fetches
A feed that silently stops updating leaves detection tools working from stale data without any visible error. Review fetch failures and the last successful pull time for each source on a regular schedule, and alert when a feed has not updated within the window you expect. Confirm with the provider how often their content changes so that your threshold reflects their actual publishing pattern.
Reviewing changes after provider updates
Providers can change formats, field meanings, tagging or indicator scope without notice, and those changes can alter what your instance imports. After a known provider update, or when volume or attribute types shift noticeably, compare a sample of new entries against the previous baseline. Re-verify the feed's mapping and filters before allowing the changed data to reach correlation or export.
Aligning distribution with sharing agreements
Distribution levels set who can see an imported attribute or event, and they must match the sharing agreement attached to each source. Review the distribution and sharing group assigned at import for every feed, and check it again when agreements change. Mismatches can expose provider data to communities the provider never approved, which may breach the terms you accepted.
Checking taxonomy and galaxy licenses
MISP taxonomies and galaxy data are licensed separately from the AGPL software license, under CC0 1.0 Universal or the 2-clause BSD license depending on the component. Check the license of each taxonomy and galaxy you enable on its own terms before using it in an internal or shared workflow. Document the result alongside your feed license records so that reviewers can trace every data source to its terms.
How tags, distribution and warning lists keep feed noise out of detection
Most noise from threat intelligence feeds does not come from volume alone. It comes from letting every imported indicator take part in correlation, tagging and sharing in the same way as analyst-created data. MISP's correlation engine matches attributes through exact matches and advanced patterns, including fuzzy hashes and CIDR overlaps, so a broad feed of IP ranges or loosely scored hashes can attach many weak links to events your team already relies on. Correlation across feeds compounds this. Two low-confidence feeds that describe the same common infrastructure produce matches that look like confirmation but carry little evidential weight. For each feed, decide how far its data is allowed to travel inside the instance and beyond it.
Start with the feed's role. A feed used only for lookups should run in cache-only mode, so its indicators are available for enrichment checks without being turned into events or correlated against your data. Feeds that carry curated, high-confidence indicators can be enabled for correlation, but only after you have reviewed a sample of what they produce. Feeds whose indicators need analyst judgment before anything is acted on are better imported as events, where a person can review and publish them. These choices are made in each feed's settings. The exact labels for caching, lookup visibility and correlation can differ between MISP versions, so confirm them against the release you run, which for new deployments is the 2.5 line recommended by the project.
Scope correlation deliberately. Enabling correlation on one feed is a decision about every event and attribute already in the instance, not just that feed's contents, so make the change after a test import on a non-production instance. Record how many correlations each feed produces on its first pull and agree on a review threshold with the analysts who will work those matches. Tags handle the sorting that correlation cannot. Apply a feed-origin tag and the relevant TLP tag at import so analysts and downstream filters can separate feed data from internal observations and exclude it when needed. Confirm whether the feed's source data already carries tags, because a tag added later may not reach attributes imported earlier.
Set distribution levels before any synchronization. MISP distributes events and attributes to other instances according to their distribution setting and sharing group, and feed-derived data pushed into a trusted community can multiply the noise you filtered locally. Choose a restrictive level for feeds that are not meant to leave the instance, and widen it only for feeds that a partner has agreed to receive. Taxonomies, galaxies and warning lists form the second layer. Warning lists flag known benign values, such as common public services, so they do not trigger detections, while taxonomies and galaxies give the remaining values consistent labels. The sibling topic on taxonomies, galaxies and warning lists covers which ones to enable and how to map them, and the workflows topic covers blocking publication when context is missing.
Limits to confirm in your environment before enabling feeds
These checks decide whether a feed is safe to switch on in your MISP instance. Feed behavior depends on the source and the MISP version in use, so confirm each item against your own deployment and the feed provider's documentation before enabling anything in production.
Supported feed formats and fetch methods
Confirm which feed formats and fetch methods the MISP version in use handles for each feed you plan to add, such as MISP format feeds, CSV and freetext. Check the release notes for that version and the feed's own format description. A feed that parses correctly in one MISP release may behave differently after an upgrade, so record the version next to each feed decision.
Credentials and network egress
List any API keys, basic authentication details or certificates a feed requires, and decide where they are stored and who can rotate them. Map the outbound destinations each fetch needs, including hosts, ports and any proxy, and confirm your egress policy allows them from the MISP server. Feeds that stop fetching often trace back to an expired credential or a blocked destination, so assign an owner to each source.
Storage and database load from large feeds
Large feeds add attributes, events and correlation work to the same storage and database the rest of the instance uses. Estimate how many records each feed adds per fetch and how often it runs, using the provider's published volume where one exists. Ask the provider for expected size and turnover, then watch disk growth and query times after a first import in a test instance.
Database and Redis sizing for expected volume
MISP depends on its database and Redis, so confirm both were sized for the total volume after feeds are added, not only the current event count. Check memory limits, connection counts and backup duration against the expected feed load. Confirm which database engines your MISP version supports for new installs before finalizing the sizing plan.
License terms for each feed
Read the license attached to every feed before enabling it. The MISP software is licensed under AGPL version 3, while taxonomies and galaxy data carry separate terms, including CC0 1.0 Universal or the 2-clause BSD license. Third-party feeds may restrict redistribution, commercial use or sharing with partners, and those limits determine whether a feed's data can be published or synchronized to other communities. Ask legal counsel to review terms that match your sharing model.
Representative feed test before production
Test each feed against a representative sample before production use. Use a non-production instance on the same MISP version, run a full fetch and a second fetch, then check parsing errors, duplicate handling, correlation hits and resource use. Record the results and the feed settings so the production change can be repeated and reviewed.
Questions buyers ask about MISP feed setup
What does a MISP feed setup engagement cost?
DeployOpen does not publish a price list. A quote follows from a written scope, and most engagements are fixed-scope, so scope, deliverables and timeline are agreed in writing before work starts.
The main cost drivers are the number of feeds to evaluate, whether feeds are added as caching, correlation or event import sources, how many sharing rules must be modeled, how much tuning the analyst review needs, and whether the feed work sits inside a new install or an existing instance. Ongoing feed review and upgrades are available as a retainer, which is a separate recurring cost.
When you request a quote, ask for the feed list, the per-feed decision for each source, the test environment included, and what your analysts must review.
How long does MISP feed configuration take?
The duration depends on the factors that change the work, not on a fixed number. The biggest variables are how many feeds you onboard, how many of them need custom CSV or freetext parsing, how many sharing groups and distribution rules must be settled first, and how quickly your analysts can review sample data.
A feed that is only cached for lookups takes less design than one that is correlated or imported as events, because imported events affect storage, sharing and detection tooling. Ask any partner to show the timeline against those factors, and confirm it in the written scope before work starts.
What must our team provide before feed setup starts?
Four inputs decide most of the schedule:
- A feed list with the sources you want, the owner of each, and the business reason for it.
- Sharing rules, including distribution levels, sharing groups and TLP handling for each feed.
- A test environment where feeds can be imported and checked without touching production detection.
- Analyst review time to judge sample events, false positive rates and whether indicators are actionable.
Missing any of these usually moves work into rework. Confirm who on your side owns each input and how much analyst time is available before the scope is signed.
Can an internal team set up MISP feeds without outside help?
Yes, many internal teams do this with the MISP documentation and their own analysts, especially for a small feed list. The work is manageable when the team already runs a MISP instance, understands its sharing model and has time to test each feed.
The effort rises when feeds need custom parsing, when correlation load must be controlled, or when sharing rules across several organizations must be agreed. An outside partner adds value mainly for design decisions and repeatable documentation. Decide based on your team's current MISP experience, available analyst hours and the number of feeds you plan to run.
Which feeds should be correlated and which should only be cached?
Correlate feeds that carry high-confidence indicators your detection stack will act on, and cache feeds that are useful for lookup but noisy. MISP's correlation engine links attributes through exact matches and advanced patterns, so every correlated feed adds relationships that analysts must be able to read.
Importing a feed as events is the heaviest choice because those events are stored, distributed and shown to analysts. A common approach is to start with cache-only, measure false positives in the test environment, then promote the feeds that earn their place. Warning lists and taxonomies can reduce noise before indicators reach detection tools.
What breaks most often after MISP feeds are switched on?
The most common problem is data volume. Feeds imported as events grow the database, slow searches and flood analysts with low-value indicators. Another frequent issue is a feed that changes its format, so CSV columns shift or freetext parsing starts missing values.
Sharing mistakes also surface later. A feed or event with a loose distribution level may be pushed to partners you did not intend to reach. Before go-live, check the sync and publish settings, confirm the parsing against a recent sample, and set a review schedule for each source. Ask the partner how monitoring and feed health checks are handled after handover.
Does the MISP version change feed setup?
Yes. MISP 2.5 is the version recommended for new deployments, and MISP 2.4 is end of life with security fixes only, so new feed work should target 2.5. The project's download page lists the supported installation options, and the recommended platform for 2.5 is Ubuntu 24.04 with the provided installer.
If your instance is on an older release, plan the upgrade before adding feeds, because feed behavior and configuration should be tested on the version you will run. Confirm the exact version and installation method with the MISP project documentation and in your scope.
What the feed work needs from your team
Before any feed is configured, your team needs to hand over a written candidate list. Each feed should have a named owner inside your organization, the license terms under which its data may be used, and a note on whether the source is a default catalog entry, a CSV feed or a freetext feed. Feeds arrive with different terms, and MISP's own content does not share one license. The MISP software is licensed under the GNU AGPL version 3, while taxonomies and galaxy data are licensed separately under CC0 1.0 Universal or the 2-clause BSD license. Your legal or procurement team should confirm the terms for each third-party feed, since the default catalog does not make those terms your terms. Ask who approves a new feed and who can withdraw one. Next, your team must define the sharing and distribution rules that apply to imported data. MISP supports distribution levels and custom sharing groups down to individual attributes, so the decision is not only whether a feed is useful but who may see it once it lands. Decide which distribution level is the default for imported events, whether any feed carries a restriction that must be preserved, and which trusted communities may receive your data through automatic synchronization. Write these rules down before the first import, because changing them after data has been shared is much harder than setting them correctly at the start. Third, name the detection tools that will consume the output. A feed is only valuable if something downstream acts on it, and the answer changes what gets imported. Your SIEM, endpoint platform, firewall or DNS filtering team should state which formats they need, such as STIX, CSV, Suricata, Snort, Zeek or RPZ, and how often they expect updates. If a consumer cannot use a particular attribute type, there is little reason to pull it into events. Ask each consuming team to confirm the format and the owner who will be paged when a feed produces noisy matches. Fourth, and most important, assign reviewers for imported data. Someone must own the review of what enters the instance, and that role cannot be left to whoever happens to run the service. The decisions that cannot be delegated to an automated process include which sources may be imported as events and which must stay cache-only, which feeds may be correlated against your internal data, and which indicators must be excluded before publishing. A cache-only feed supports lookups without creating events that other organizations might receive, so a source with restrictive terms or low confidence should usually start there. Record each decision with the reviewer's name and the date so the choice can be explained later. Finally, confirm who approves changes after go-live. Feed owners, the reviewer and the detection consumers should agree on a process for adding a feed, retiring one and handling a source that starts producing large volumes of low-value data. Ask your implementation partner to document those decisions in the scope, so that the handover identifies who maintains the feed list once the initial configuration is complete.
How DeployOpen scopes and delivers MISP feed setup
DeployOpen plans, builds, documents and supports self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. For MISP feed setup, we agree the feed list, the handling choice for each feed and the verification steps in writing before any work starts, then deliver to that scope.
How we scope
- Inventory the default feed catalog and decide which feeds your teams actually need
- Record, for each feed, whether it is cached for lookups, correlated or imported as events
- Define the CSV and freetext feed sources, their formats and their update cadence
- Confirm the MISP version, database and hosting target before the build begins
- Engagements are fixed-scope, with deliverables and timelines agreed in writing
How we build
- Configure the selected default feeds and enable only the handling mode agreed for each
- Build CSV and freetext feed definitions with field mapping and tagging rules
- Test that low-value feeds stay out of correlation so the instance does not fill with noise
- Check that feed fetches, caching and imports run on schedule and log clearly on failure
- Review each change with your team before it reaches the production instance
How we hand over
- Deliver a feed register listing each source, its handling mode, owner and review date
- Document how to add, retire or change a feed without disrupting correlation
- Provide a verification checklist your analysts can repeat after each feed change
- Walk your operators through monitoring fetch errors and cleaning up stale indicators
- Transfer configuration and documentation to your team in your own repositories
How we support
- Ongoing support, upgrades and feed reviews are available as a retainer
- Review feed value periodically and recommend changes to handling modes
- Plan MISP upgrades so feed configuration is checked against each new release
- Confirm with us in the written scope which support hours and response terms apply

