MISP vs OpenCTI vs Yeti

MISP suits teams that share indicators with other organizations, OpenCTI suits teams that model and report on intelligence as STIX knowledge, and Yeti suits DFIR analysts who keep forensic artifacts next to their intelligence. Choose by the job you need done first.

On this page

Which threat intelligence platform fits your team

Choose MISP if your main goal is exchanging indicators with other organizations, peer groups or sector communities. MISP is licensed under AGPL-3.0, its sharing model uses distribution levels and sharing groups that can be set down to individual attributes, and it synchronizes events between instances. Choose OpenCTI if you need a structured knowledge base of threat actors, campaigns, malware and their relationships, modeled on STIX-based entities. The Community Edition is Apache-2.0, but audit logs, playbooks and automation, organization segregation and SSO through OpenID, LDAP or SAML sit in the paid Enterprise Edition. Choose Yeti if a DFIR team wants to keep threat intelligence next to forensic artifacts, Sigma and YARA rules, and reusable hunting queries. Yeti is Apache-2.0, built with FastAPI and ArangoDB, and aimed at analysts rather than community sharing.

The three overlap less than their feature lists suggest. MISP and OpenCTI both import and export indicators, and OpenCTI has a MISP connector, but the sharing hub and the analysis workspace answer different questions. Yeti sits closer to the investigation than to either. Before you shortlist, confirm three things with your own team: who will receive shared intelligence and under what distribution rules, whether analysts need the knowledge graph and reporting or only a searchable store, and whether SSO, audit logging and automation are required, since those gate the OpenCTI Enterprise Edition. Confirm current license terms and paid features directly with each vendor before budgeting.

Many mature teams run two of these platforms rather than forcing one to do everything. A common split is MISP as the sharing hub with OpenCTI or Yeti for analysis, but each extra platform adds hosting, upgrades, and a second copy of data to keep consistent. If you go that way, decide early which system is the source of truth for each indicator. Plan for the operating effort of each stack, including OpenCTI's dependencies on Elasticsearch or OpenSearch, Redis, RabbitMQ and S3-compatible storage, before you commit.

Which platform fits which scenario

This table maps common team scenarios to the platform that fits best and the reason, using licensing, data model and workflow facts from the sources. Read each row as a starting point: the deciding condition is usually who you share with, what you store, and who will run the platform.

ScenarioBest fitReason and condition
Sharing indicators with peer organizationsMISPDistribution levels and sharing groups go down to individual attributes, and events synchronize automatically between MISP instances and trusted communities. This matters most when partners need to exchange IOCs under controlled terms.
Building a STIX knowledge base for reportingOpenCTIIntelligence is organized as STIX-based entities and relationships, and connectors import data from MISP, MITRE and CVE sources. Choose it when analysts need a linked knowledge graph for reports, though audit logs, playbooks and SSO features need the paid Enterprise Edition.
DFIR teams that keep forensic artifacts with intelligenceYetiYeti stores DFIQ objects, forensic artifact definitions, Sigma and YARA rules and reusable queries alongside threat intelligence, with Timesketch and MITRE ATT&CK integration. It suits analysts who hunt from a threat to its artifacts, not partners who need to share at scale.
Teams that need indicator exports for SIEM or network sensorsMISPMISP exports Suricata, Snort, Zeek and STIX formats through its REST API and PyMISP library. Confirm that your SIEM or sensor accepts the export format you need before you commit.
Teams that already run a SIEM or SOARDepends on the roleMISP fits when the SOAR must pull and push sharing events. OpenCTI fits when the SOAR must query a knowledge graph. Yeti fits when the SIEM needs forensic artifacts and rules. Confirm the connector or API path with each vendor.
Small team with limited platform operations capacityYeti or MISP, depending on scopeYeti and MISP are single-application stacks with fewer required services than OpenCTI. OpenCTI needs Elasticsearch or OpenSearch, Redis, RabbitMQ and S3-compatible storage, so plan the operating effort before choosing it.
Teams that must keep the license fully open sourceMISP or YetiMISP is AGPL-3.0 and Yeti is Apache-2.0. OpenCTI's Community Edition is Apache-2.0, but features such as audit logs and SSO through OpenID, LDAP or SAML require the proprietary Enterprise Edition, so confirm which features your team needs.
Organizations that need LTS support for OpenCTIOpenCTIOpenCTI publishes LTS builds with an lts suffix that receive critical bug and security fixes after stabilization. LTS use requires a specific license key, so confirm entitlement and support windows directly with Filigran before planning upgrades.

What is free and what is paid in each platform

MISP is licensed under the GNU AGPL version 3, and the project states that interlocked copyright among contributors prevents any single entity from changing that license model. Taxonomies and galaxy data carry their own terms: they are published under CC0 1.0 Universal or the 2-clause BSD license, separate from the software license. The supplied facts describe no paid MISP edition, so the cost question is operational. MISP 2.5 is the recommended line for new deployments, and MISP 2.4 is end of life with security fixes only.

  • Software license: AGPL-3.0 covers the MISP code, so modifications you distribute or run as a network service carry source obligations.
  • Data licenses: Taxonomies and galaxies are CC0 or BSD, which lets you reuse and redistribute them under those terms.
  • Version choice: MISP 2.5 is recommended for new deployments; the project strongly advises against installing new 2.4 instances.
  • Upgrade path: The project provides an upgrade script for Ubuntu for moving existing 2.4 installs forward.
  • Paid services: Support and training come from the project and third parties, not from a licensed edition. Confirm the support options and their terms directly with the MISP project before you rely on them.

Before you commit, confirm with your legal team how the AGPL-3.0 applies to any changes you plan to make, and check the MISP support page for current options.

How MISP, OpenCTI and Yeti store and move intelligence

The three platforms organize intelligence in fundamentally different units, and that choice shapes what moves cleanly between them. MISP stores *events* that contain *attributes* (single indicators such as an IP address, file hash or domain) and *objects* that group related attributes. Each event carries a distribution level and, where needed, a sharing group, which decide who receives it when MISP instances synchronize. OpenCTI stores intelligence as STIX-based entities (threat actors, malware, indicators, reports) linked by typed relationships in a knowledge graph, and most of its content arrives through connectors, including a MISP connector. Yeti centers on *observables*, *entities* such as threat actors and campaigns, and *indicators*, and it also holds DFIQ objects, forensic artifact definitions, Sigma and YARA rules and reusable queries alongside them.

Export paths follow from those models. MISP exports MISP JSON, STIX 1 and 2, CSV and detection formats such as Suricata, Snort and Zeek rules through its REST API, so a sensor team can consume MISP output without OpenCTI in the path. OpenCTI exports through its connector framework, and STIX 2.1 is the common language to confirm for any hand-off. Yeti's custom export formats target SIEM and DFIR tools, which suits detection engineering but not a general sharing feed. Before committing to a pipeline, run a test: export a sample set from each platform, import it into the other, and count what survives, especially relationships, sharing restrictions, and any Yeti-only artifacts. Confirm with each vendor which fields round-trip and which are dropped, since a lossy import is the most common hidden cost of running two platforms.

What drives the running cost of each platform

Running cost for MISP, OpenCTI and Yeti comes from the same few places: the servers and services each platform needs, the upgrade work that recurs, the license tier you need, and the analyst hours spent keeping feeds and connectors healthy. The cards below separate what you pay once from what recurs, so you can ask each vendor or partner for a quote that covers the right items.

OpenCTI platform, search and worker footprint

OpenCTI is a stateless platform with a GraphQL API, Python workers and connectors, and it depends on Elasticsearch or OpenSearch, Redis, RabbitMQ and S3-compatible storage. The documented sizing gives the platform 2 cores and at least 8 GB RAM, and the search layer 2 cores, 8 GB RAM and 16 GB SSD, with at least one platform node for every 3 workers. Recurring cost rises with worker count and data volume, so ask a quote to size each of these components and the storage growth you expect.

MISP install path and upgrade cycle

MISP 2.5 is the recommended line for new deployments, and the project lists a native Ubuntu 24.04 installer, Docker images, Ansible roles, Puppet and RPM packages. The choice sets who carries the upgrade work each time a release lands, and MISP 2.4 is end of life with security fixes only, so legacy installs carry a migration cost. Ask whether your partner's effort covers the chosen path, the database migration system and any PostgreSQL move.

Yeti and its ArangoDB operation

Yeti is a Python application built on FastAPI and ArangoDB, so the database is the component your team must patch, back up and size. Yeti's Apache-2.0 license carries no license fee, which moves the recurring cost into operations: database administration, Python dependency updates and release tracking. Ask who owns ArangoDB backups and restore testing, because a forensic knowledge base is hard to rebuild from scratch.

Analyst time for feeds and connectors

Each platform ingests data differently, and connectors, feed selection and enrichment rules need continuous attention. OpenCTI connectors for MISP, MITRE and CVE data must be kept running and monitored, MISP feeds and sharing groups need curation, and Yeti data sources need analyst review. This labor is the largest recurring cost in many deployments, and it scales with the number of sources rather than with license tier, so estimate it from the sources you plan to run.

Enterprise license subscriptions

OpenCTI Enterprise Edition requires a paid subscription, and it gates audit logs, playbooks and automation, organization segregation and SSO through OpenID, LDAP or SAML. OpenCTI LTS releases also need a specific LTS license key. MISP and Yeti do not carry a comparable paid edition in the supplied facts, so confirm any support contract or hosted option directly with each vendor. Ask every quote to state which features the subscription unlocks and whether it renews annually.

Upgrade and LTS planning

OpenCTI LTS builds arrive about every six months and are supported for one year, with a six-month overlap between consecutive LTS versions, so teams that stay on LTS plan an upgrade roughly twice a year. Non-LTS releases ship from daily to weekly, which suits teams that test often. Budget the testing and change window for whichever cadence you choose, and confirm how your partner handles upgrades under a retainer.

How a typical implementation proceeds

This sequence moves a team from an undefined threat intelligence need to a running platform with agreed access rules, tested integrations and written operating documentation. Each step ends with a checkpoint so the team knows whether to continue, change the platform choice or adjust scope.

  1. Define the primary job for the platform

    The team decides which job comes first: sharing indicators with partner organizations (MISP), building a structured knowledge base that links intelligence to reports and campaigns (OpenCTI), or supporting forensic investigations that keep artifacts, Sigma and YARA rules next to intelligence (Yeti). DeployOpen runs this workshop with the security lead and analysts, and the output is a written statement of the primary job, the secondary jobs and the users who must be served first. Done means the sponsor has signed off on one primary platform, or has explicitly accepted a two-platform design that the later steps will cover.

  2. Confirm license and edition requirements

    Before any installation, the team checks which features it needs and which edition provides them. MISP is AGPL-3.0 with no paid edition. OpenCTI Community Edition is Apache-2.0, but audit logs, playbooks, organization segregation and SSO through OpenID, LDAP or SAML require the Enterprise Edition. Yeti is Apache-2.0. The client's legal and procurement teams confirm how AGPL-3.0 obligations apply to any modifications they plan to make, and they request OpenCTI Enterprise pricing and terms in writing if SSO or audit logging is required. Done means a feature-to-edition matrix is approved and the quote request lists every gated feature.

  3. Size the infrastructure for the chosen platform

    Sizing depends on the platform. OpenCTI documents a platform with 2 cores and at least 8 GB RAM, Elasticsearch or OpenSearch with 2 cores, 8 GB RAM and 16 GB SSD, and at least one platform node for every 3 workers, and it also needs Redis, RabbitMQ and S3-compatible storage. MISP runs on PHP with MySQL or MariaDB and Redis. Yeti uses ArangoDB. The infrastructure team confirms the hosting model, backup approach and network zones inside its own cloud account, data center or air-gapped network, and checks these numbers against the vendor's current documentation. Done means a reviewed architecture diagram and a capacity plan exist for the selected platform.

  4. Install the platform in a staging environment

    DeployOpen installs the platform in a non-production environment that matches the target architecture. For MISP, the team chooses between the project's Ubuntu installer on the recommended release line, Docker images, Ansible roles or RPM packages. For OpenCTI, the team selects a release line, and if it chooses an LTS build it must hold a valid LTS license key. For Yeti, the team deploys the Python and FastAPI service with ArangoDB. Done means the staging instance starts, the database and queue services report healthy, and the installation steps are recorded in the runbook.

  5. Integrate feeds, connectors and data sources

    The team connects the sources it actually uses. In MISP, that means default feeds, community sync partners and export targets such as Suricata, Snort, Zeek or STIX. In OpenCTI, that means connectors for MISP, MITRE ATT&CK and CVE data, with each connector's data volume checked against the sizing plan. In Yeti, that means configuring data sources, analytics and the Timesketch link if the DFIR team uses it. Partner-specific feeds and sharing agreements come from the client's own relationships and contracts. Done means each source has a documented owner, a test import has completed and the import results were reviewed by an analyst.

  6. Set access controls and sharing rules

    The team defines who can read, create and share intelligence. In MISP, this means distribution levels, sharing groups and organization roles, applied down to individual attributes where needed. In OpenCTI, this means organization segregation and identity configuration, which may require the Enterprise Edition. In Yeti, this means user and ACL configuration for analysts. The identity team connects the chosen SSO method and confirms that the platform's authentication settings match the client's policy. Done means a test matrix covering each role and sharing scope has been run, and the results show that data is visible only to the intended audiences.

  7. Test, harden and document the deployment

    DeployOpen tests the deployment against the approved requirements, including upgrade and restore procedures, and documents the configuration, data flows and operational owners. Security testing of the platform itself can be scoped separately under the security testing services. Compliance evidence is prepared for the client's assessor, but DeployOpen does not issue attestations or certifications. Done means the acceptance test is signed off by the client, the runbook covers upgrades and backups, and the client knows which release line it will follow and who monitors vendor announcements.

What implementing each platform involves

Effort differs more by platform than by license. MISP 2.5 is the recommended version for new deployments, and the project recommends Ubuntu 24.04 with its provided installer, while Docker images, Ansible roles, Puppet and RPM packages are also listed. Since MISP 2.5.47 introduced a new database migration system with PostgreSQL support, the database choice is a decision to make before go-live rather than a later migration project, so confirm with your DBA whether your standard is MySQL or MariaDB or PostgreSQL. Treat the upgrade path as recurring work: MISP 2.4 is end of life with security fixes only, so any legacy 2.4 instance needs a planned move to 2.5 and the project's upgrade script for Ubuntu is the starting point to test against a copy of your data.

OpenCTI carries the heaviest footprint of the three. A deployment combines the platform, Python workers consuming RabbitMQ messages, connectors, and dependencies including Elasticsearch 8.0 or later or OpenSearch 2.9 or later, Redis 7.1 or later, RabbitMQ 3.11 or later and S3-compatible storage. Ask who owns each of those services and their backups before you commit. If you adopt an LTS line, the LTS builds are distributed as container images but require a specific LTS license key, so add key issuance and renewal to your change calendar. Audit logs, playbooks, organization segregation and OpenID, LDAP or SAML single sign-on sit behind the Enterprise Edition, so confirm which of these you need on day one with Filigran before scoping.

Yeti is the lightest to stand up but shifts effort into integration work. Its web API supports automated queries and enrichment, and pluggable data sources and analytics let your engineers add feeds and exports, so budget for that development. Whichever platform you pick, your team must supply the identity provider for single sign-on, the storage and retention plan, the feed agreements that decide which indicators arrive, a written sharing policy covering distribution levels and sharing groups if you use MISP, and analysts who will actually use the platform daily. Confirm each of these in writing during scoping, because they drive more of the total effort than the software install does.

Questions buyers ask before choosing a threat intelligence platform

What does implementing MISP, OpenCTI or Yeti cost, and what drives it?

Software licenses are only part of the cost. MISP (AGPL-3.0), OpenCTI Community Edition (Apache-2.0) and Yeti (Apache-2.0) carry no license fee for the community code, but OpenCTI Enterprise Edition needs a paid subscription and LTS builds need a specific license key. The larger costs are one-time implementation work and recurring operations. Drivers include the number of users and sources, the sharing or enrichment connectors you need, hosting footprint, integrations with your SIEM or case management tools, and how much hardening and documentation you require. Ask any implementation partner for a fixed-scope quote with written deliverables, the hosting assumptions behind it, and a separate line for ongoing support or upgrades. Ask the OpenCTI vendor for current Enterprise pricing directly, since no public price list is available from DeployOpen.

How long does a threat intelligence platform rollout take?

No duration is fixed for these platforms, and the answer depends on the work around the software. Timing is driven by the number of data sources and connectors, how sharing communities or trusted partners must be onboarded, identity integration, hardening requirements, and whether your team needs training before it takes ownership. OpenCTI adds infrastructure work because it depends on Elasticsearch or OpenSearch, Redis, RabbitMQ and S3-compatible storage, so those components must be provisioned and sized first. DeployOpen typically agrees timelines in the written scope before work starts. Ask for a timeline with milestones tied to named deliverables, and confirm which dependencies are your responsibility and which are the implementer's.

Can our team run these platforms without outside help?

It depends on the team's skills and the operating model you choose. MISP is a PHP and MySQL or MariaDB application with Redis, installable natively on Ubuntu 24.04 or through Docker images, Ansible roles, Puppet or RPM packages, so a team with Linux and web application administration skills can manage it. OpenCTI is a larger stack with a GraphQL platform, Python workers, connectors and several data services, so it needs operators comfortable with distributed systems and sizing. Yeti depends on Python, FastAPI and ArangoDB. Before deciding, check whether you have on-call coverage, upgrade capacity for release cadence, and someone who owns connector maintenance. Outside help can cover implementation, hardening, documentation and retainer support, but ownership should stay with a named internal person.

Which SSO features need the OpenCTI Enterprise Edition?

According to the OpenCTI documentation, SSO configuration through OpenID, LDAP or SAML requires OpenCTI Enterprise Edition, along with audit logs, playbooks and automation, and organization segregation. The Community Edition is licensed under Apache-2.0, and Enterprise files fall under a separate proprietary license. Confirm the exact gating for your version with Filigran before you design around it, because feature availability can change between releases. For MISP, the project publishes an OidcAuth plugin README, so OpenID Connect integration is documented in the MISP codebase under AGPL-3.0. Yeti 2.12.0 added a Google access token exchange endpoint, disabled by default. Verify each option in a lab build before you commit to an identity design.

How do we move indicators and data between MISP, OpenCTI and Yeti?

Start by deciding which platform holds the authoritative copy of each data type. MISP exports MISP JSON, STIX 1 and 2, CSV and detection formats such as Suricata, Snort and Zeek through its REST API, and PyMISP automates exports. OpenCTI organizes data as STIX-based entities and relationships and imports sources through connectors, including MISP, MITRE and CVE connectors. Yeti supports custom export formats for SIEM and DFIR tools. Expect mapping work where object models differ, especially for MISP events and attributes versus STIX entities. Ask any implementer to document field mappings, a test dataset, a validation method for counts and relationships, and a rollback plan. Agree in writing who owns mapping logic after the migration.

Is running two threat intelligence platforms worth the operational cost?

Running two platforms makes sense when they serve different jobs, such as community sharing in MISP and analyst knowledge management in OpenCTI, but each one adds infrastructure, upgrades, access control and data duplication. OpenCTI alone needs its own database, search, queue, cache and object storage services, and it recommends at least one platform node for every three workers. Duplicated indicators also raise questions about which copy is authoritative during an incident. Before choosing two, list the consumers of each dataset, the sync method, the owner of each platform, and the change process for connectors. If one platform can meet the sharing and analysis needs, a single deployment is usually easier to operate. Ask for a written operating model before approving a second platform.

Does the AGPL-3.0 or Apache-2.0 license limit how we use these platforms internally?

Both licenses permit internal use of the community code, but they differ in obligations. MISP is licensed under AGPL-3.0, which includes network-use source sharing terms if you modify the software and make it available to users over a network, and its repository notes that interlocked copyright prevents a single entity from changing the license model. OpenCTI Community Edition and Yeti are Apache-2.0, which is generally permissive, while OpenCTI Enterprise files fall under the proprietary OpenCTI Enterprise Edition License. MISP taxonomies and galaxies carry separate CC0 1.0 or BSD-2-Clause terms. Confirm how these terms apply to your modifications, connectors and hosted service with your legal counsel before you deploy or customize.

What changes if you switch platforms later

Switching later costs more in data shape and sharing relationships than in software. MISP events and attributes move out through MISP JSON, STIX 1 and 2, or CSV, but a STIX export does not carry MISP's sharing groups, distribution levels or synchronization links with partner instances. Those trust relationships have to be rebuilt by hand on the new side, and any partner who has not agreed to the new feed must be re-onboarded. OpenCTI's MISP connector can import MISP events into its STIX knowledge graph, which helps with history, but it is one-way ingestion for analysis, not a replacement for being a sharing hub. Yeti is the hardest to leave: observables, DFIQ objects, Sigma and YARA rules and saved queries sit in its ArangoDB-backed model, so confirm with the vendor and in a test export which of these come out in a usable form before you commit analyst workflows to them.

Analyst retraining and integrations usually cost more than the data move. Analysts who learn MISP's event and attribute model, OpenCTI's STIX entities and relationships, or Yeti's observable and artifact workflow will need to relearn search, correlation and reporting on the new platform. Every SIEM, SOAR or enrichment integration that calls the MISP REST API, the OpenCTI GraphQL API or Yeti's web API must also be repointed and retested. Ask your implementation partner for a written inventory of these integrations and of the custom export formats you depend on, since those are the items that break silently during a migration.

In the first deployment, preserve exportable and identity-neutral state. Keep sharing agreements, distribution rules and taxonomy choices documented outside the platform, so they can be reapplied elsewhere. Schedule periodic test exports in the formats you care about, and keep the platform-specific IDs needed to correlate records across systems. For single sign-on, confirm which identity features each platform gates behind its paid tier before you design around them, because OpenCTI's audit logs, playbooks and SSO options through OpenID, LDAP or SAML require its Enterprise Edition. Document your upgrade cadence too: MISP 2.4 is end of life, and OpenCTI LTS builds require a specific license key, so a version you cannot upgrade is also a switching cost.

How DeployOpen helps choose and implement a threat intelligence platform

DeployOpen plans, implements, integrates, hardens and documents self-hosted open-source platforms inside your own infrastructure, so the choice between MISP, OpenCTI and Yeti can be tested against your sharing obligations, analyst workflows and hosting constraints. Each engagement starts from a written scope and ends with a documented, handed-over system.

How we scope

  • Map which teams share indicators externally and which build forensic intelligence internally
  • Confirm the sharing communities, distribution levels and sharing groups MISP would need to serve
  • Record licensing requirements, including AGPL-3.0 obligations and OpenCTI Enterprise Edition features you need

How we build

  • Deploy the chosen platform in your cloud account, data center or air-gapped network
  • Configure SSO, feeds, taxonomies and connectors against the scoped data sources
  • Test correlation, export formats and API automation with your own sample intelligence before rollout

How we hand over

  • Document architecture, dependencies, sizing and upgrade procedures for your operations team
  • Deliver written runbooks for feed onboarding, sharing rules and backup and restore
  • Walk administrators through analyst workflows so ownership stays with your staff

How we support

  • Offer ongoing support, upgrades and continuous testing as a retainer after handover
  • Track release lines and LTS support windows so upgrades follow your change calendar
  • Revisit the platform choice when sharing partners, team size or compliance scope changes

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.