OpenCTI and Microsoft Sentinel integration

Plan and configure the OpenCTI and Microsoft Sentinel integration that sends indicators to Sentinel and brings incidents back, with the identity, version and verification steps your team needs to confirm.

On this page

OpenCTI and Microsoft Sentinel integration: what moves between the two platforms

Use this integration when a security team wants OpenCTI indicators available to Sentinel detection logic and wants Sentinel incidents to enrich the OpenCTI knowledge graph. The supported method for the indicator direction is the Upload Indicators API, and incidents return to OpenCTI through an incident import. Before build, confirm the exact connector name, its minimum OpenCTI version and its configuration keys in the OpenCTI connectors repository and in Microsoft's API documentation, because these details change between releases and should be taken from those sources at build time. DeployOpen plans and implements the connection inside your own cloud tenancy and your own OpenCTI deployment. This page covers both directions and sets out the boundary of each.

The indicator direction starts with a selection decision. OpenCTI holds far more than indicators, so the team needs to decide which indicators are exported, using filters on labels, TLP marking, score, validity dates and entity type. Each exported indicator should carry an expiry so that stale indicators do not remain active in Sentinel after the threat has passed. Authentication is the second decision. Confirm whether the chosen connector accepts an Microsoft Entra app registration with a client secret or certificate, or a managed identity running on your own compute, and confirm the role assignment needed on the target Sentinel workspace. Record these choices before anyone builds the pipeline, since changing them later means reissuing credentials and rechecking every filter.

The incident direction moves Sentinel incidents and their alerts into OpenCTI so that investigations add context to the graph. The team must decide how Sentinel severity and status map to OpenCTI fields, and which observables from alerts become OpenCTI observables. The main risk is a feedback loop. An indicator exported from OpenCTI can match activity in Sentinel, and the resulting incident can be imported back as new data that points to the same indicator. Confirm how the connector identifies objects it has already written, using external references or stable identifiers, so that repeated polls update existing records instead of duplicating them. OpenCTI should enrich investigations, but Sentinel remains the system of record for SOC case handling, response actions and analyst assignment.

Plan verification and operations before go-live. Test in a non-production Sentinel workspace and confirm the API rate limits and quotas that apply to your tenancy in Microsoft's documentation. Check that the connector logs failed exports and failed imports, and that someone owns the alerting on those logs. Credentials need a rotation schedule that matches your identity policy. OpenCTI upgrades can change connector behavior or configuration keys, so each platform upgrade should include a retest of both directions. Cost comes from implementation scope, from the connector and infrastructure you run, and from Sentinel ingestion and API usage, which Microsoft prices separately. Ask any quote to name the connector version, the two directions in scope, the test evidence delivered and the runbook handed over.

What the OpenCTI and Microsoft Sentinel integration needs before you start

The integration depends on three sides working together: a running OpenCTI platform, a Microsoft Sentinel workspace with the right identity and permissions, and network paths from the connector host to Microsoft endpoints. Confirm each side before scheduling the build, because a gap in any one of them stops indicator streaming or incident import even when the other two are ready.

Running OpenCTI platform and dependencies

The connector needs a working OpenCTI instance first. The deployment overview lists the platform, Python workers, RabbitMQ, Redis, Elasticsearch or OpenSearch, and S3-compatible storage, along with documented sizing for each. Confirm that the platform is healthy and that its workers are processing messages, because a stalled queue shows up as missing indicators in Sentinel rather than as an obvious error.

Community or Enterprise release line

Decide early whether the deployment runs the Community Edition under Apache License 2.0 or the Enterprise Edition under its proprietary license, and whether it follows regular releases or an LTS line. LTS releases require a specific license key. Confirm the minimum OpenCTI version for the Sentinel connector in its documentation and the current release line, rather than assuming that a version you already run meets it.

OpenCTI connector credential

Create a dedicated OpenCTI account or connector token for the Sentinel connector, scoped to the data it reads. Avoid reusing an administrator's personal credential, because rotating or revoking that credential would break the stream. Record who owns the token, where it is stored, and how it is rotated.

Sentinel workspace and target scope

Identify the Log Analytics workspace that backs Microsoft Sentinel and confirm it is the one that will receive indicators and be queried for incidents. Check its region, retention settings and any access restrictions already applied. Changing the target workspace later means reviewing every indicator record and detection that depends on it.

API permissions for the chosen path

The Upload Indicators API and the incident read path require different Azure role assignments. Confirm which API your connector version uses, then grant only the permissions that API needs at the workspace or resource group level. Have the Azure administrator review the assignment in writing, since over-broad roles on a security workspace are a common finding.

Entra app registration or managed identity

Choose between an Entra app registration with a client secret or certificate and a managed identity on the connector host. A managed identity avoids storing a long-lived secret, but it requires the connector to run on Azure infrastructure that supports it. Document the chosen identity, its owner, and the process for rotating secrets or certificates if an app registration is used.

Outbound HTTPS, DNS and proxy rules

The connector host must reach the Microsoft login and Azure Monitor endpoints over outbound HTTPS. Confirm DNS resolution for those endpoints from inside the network, and check whether a proxy or firewall performs TLS inspection that would break token exchange. Test the path from the actual connector host, not from a workstation, because server egress rules often differ.

How indicators stream to Sentinel and incidents return to OpenCTI

The integration runs as two separate data paths, and each needs its own decisions. The outbound path carries indicators from OpenCTI to a Sentinel workspace. A connector consumes the stream of indicator events, applies its filters, and sends matching indicators through the Upload Indicators API to the target workspace. The platform does not call Sentinel directly. The work happens in a connector container that runs alongside the platform. Ask whether the connector consumes the stream continuously or runs on a schedule, because that decides whether changes reach Sentinel as they happen or in batches. Confirm the filter options, such as indicator type, labels or marking definitions, against the connector's own documentation before you enable it.

Both paths depend on the worker model. The deployment overview describes Python workers that consume RabbitMQ messages for asynchronous writes, and connectors use the same message-driven pattern to exchange data with the platform. A stalled queue, a stopped worker or an exhausted RabbitMQ volume can delay indicators leaving OpenCTI or incidents entering it, even when the web interface looks healthy. Plan monitoring for queue backlog and connector logs from day one. Size the worker count against the documented guidance of at least one platform node for every 3 workers, then validate that sizing against your own indicator volume and the number of connectors you intend to run.

The inbound path reads Sentinel incidents and creates corresponding STIX objects in OpenCTI. The connector queries Sentinel for incidents within a configured scope, converts each one into STIX objects, and writes them through the platform so they enter the knowledge graph like any other data. Before go-live, decide which incident fields map to which STIX object types, and which workspace and time window the connector reads. Confirm in the connector documentation whether updates to an existing Sentinel incident are reflected in OpenCTI or whether they create duplicate objects. That behavior determines how analysts will read the imported data and how much cleanup you will need later.

Direction, filters and frequency for each path are set in the connector configuration. Outbound and inbound settings are usually held in separate connector instances, so their values can differ, and you should record the value chosen for each. Check those settings again after any upgrade, because option names and defaults can change between connector releases. Test with a small, clearly labeled set of indicators first. Confirm that the objects appear in Sentinel, then trigger a known test incident and check that the expected STIX objects appear in OpenCTI. Widen the scope only after both checks pass. Confirm the minimum OpenCTI version that the connector supports with its documentation and your chosen release line.

Setting up the OpenCTI and Microsoft Sentinel integration step by step

This sequence connects a self-hosted OpenCTI platform to Microsoft Sentinel in both directions: indicators flow out to Sentinel and incidents flow back into OpenCTI. Each step ends with a check you can record, so a failed check stops the work before the scope grows. Work through the steps in order and start in a non-production scope.

  1. Confirm the OpenCTI release line

    The platform team records which OpenCTI release runs in the environment, either a regular release or an LTS line, and checks the connector documentation for that exact version. Regular releases use date-based numbers in the form x.YYMMDD.z, and LTS releases add an -lts.n suffix. LTS lines require a specific LTS license key and receive only critical bug and security fixes after stabilization. Confirm the minimum supported OpenCTI version with the connector documentation. Check: the running build appears on the connector's supported list, and the version is written in the deployment record.

  2. Create the Sentinel access path

    The cloud or security team decides how the connector authenticates to Microsoft Sentinel: an Entra app registration with a client secret, a federated credential, or a managed identity where the connector host supports one. They identify the Sentinel workspace, its resource group and the Entra tenant that owns it, and record each value in the deployment plan. Confirm the workspace is reachable from the network segment where the connector runs. Check: the identity exists in the correct tenant, its owner is recorded, and a test token request from the connector host succeeds.

  3. Grant least API permissions and store credentials

    Assign only the API permissions that the connector documentation lists for indicator upload and incident read. Do not grant broader roles to make a test pass. Store the client secret or federated credential in the secret store your organization already operates, with read access limited to the team that runs the connector. Permission names and secret handling options are set by the documentation for your release, so copy them from there and record the version you checked. Check: a test call performs the documented upload action, and the identity fails any action outside the documented list.

  4. Configure the connector and indicator filters

    The OpenCTI administrator enters the workspace, tenant and identity values from step two, then defines indicator filters before anything is sent. Filters decide which indicators are uploaded, commonly by entity type, labels, marking definitions and score, and each choice should match the detections that will use the data. Confirm the configuration keys and filter syntax in the connector documentation for your release, and do not reuse examples from older versions. Check: the connector validates its configuration on startup, and the filter summary in its logs matches the planned indicator set.

  5. Start in non-production and confirm arrival

    Start the connector against a non-production Sentinel workspace or a limited set of test indicators, and watch the connector logs for upload results. In Sentinel, confirm that indicators arrive with the expected values, labels and expiry, and that a known test indicator from OpenCTI matches what Sentinel stores. Record the count of uploaded and rejected indicators along with the reason for each rejection type. Check: the known test indicator appears in the workspace with matching values, and every rejection reason is understood and documented.

  6. Configure the incident import with limited scope

    Enable the inbound incident import only after indicator flow is confirmed, and limit it to a narrow scope chosen by the platform team, such as one workspace, one severity level or a short time window. Confirm that the import identity holds only the read permissions the documentation lists for incidents. Set the labels or markings that tag imported objects so they can be found and separated later. Check: the import run completes without errors, and the number of incidents read matches the scope you defined.

  7. Confirm incidents appear in OpenCTI

    Open OpenCTI and locate the incidents from the limited import. For each sampled record, confirm the source label, the related observables or indicators, and the markings your policy requires. Compare titles, severities and identifiers with the originals in Sentinel to confirm that nothing is duplicated or linked to the wrong entity. Log any mapping gaps and fix them before the scope grows. Check: the sampled incidents match Sentinel on title, severity and identifier, and a repeat import run creates no duplicate objects.

  8. Widen scope and document the configuration

    Widen indicator filters and incident scope in stages, and repeat the checks from steps five and seven after each change. Record the OpenCTI version, connector version, Sentinel workspace, identity type, permissions granted, secret location, indicator filters and import scope in the runbook. Name an owner for secret rotation and for connector reviews at each OpenCTI release change. Check: a reviewer who did not build the integration can rebuild the configuration from the runbook alone, and each scope change has a dated entry.

How OpenCTI indicators and incidents map to Sentinel fields

This table compares each OpenCTI object or property that the integration moves with the Sentinel field it lands in, and names the decision the team must make for each. Sentinel field names are marked for confirmation because they must be checked against the connector and the Sentinel API schema before build. The main takeaway is that most mapping failures come from decisions left implicit, such as TLP handling, expiry and re-import behavior.

Mapping areaDecision the team must makeRisk if left implicit
Indicator observables and patternsChoose whether to export observables, STIX indicators with patterns, or both. Sentinel property names to be confirmed.Values arrive without a usable pattern or type, so matching and alerting fail silently.
STIX entity types selected for exportLimit export to indicator-linked types. Confirm the connector's supported entity types and filters.Unfiltered export floods the workspace with low-value objects and inflates ingestion volume.
Labels and TLP markingsMap labels to Sentinel tags (field to be confirmed). Decide whether TLP markings block export before sending.TLP:RED material may reach analysts or workspaces outside its handling rules.
Validity dates and revocationMap valid_from, valid_until and revoked to Sentinel active and expiry fields (names to be confirmed). Set a default expiry for open-ended indicators.Revoked or expired indicators keep alerting, and stale indicators accumulate.
Confidence and severityDecide how OpenCTI confidence maps to the Sentinel confidence field and which threshold is exported.Low-confidence indicators drive high-severity detections and analyst fatigue.
Sentinel incidents into OpenCTIMap incident title, severity, status and linked entities to Incident or Case objects. Confirm field names in the API schema.Re-imports create duplicate incidents, and status changes made in Sentinel are lost.
External identifiers for updatesStore the source object ID on both sides so re-runs update existing records.Without a shared key, every sync run duplicates indicators and incidents.

Entra app registration or managed identity: choosing how the connector signs in

The connector can sign in to Microsoft Sentinel in two main ways: with an Entra app registration that authenticates by client secret or certificate, or with a managed identity assigned to the Azure host the connector runs on. Settle this decision before deployment, because it determines where the connector can run, who owns the credential, and how rotation is handled. Confirm in the connector's documentation which option it supports, since support can vary by connector version and packaging.

An app registration is owned by your identity team. That team creates the object, holds the secret or certificate, and sets its expiry. The credential has to be stored in the OpenCTI deployment's secret handling, and rotation becomes a recurring task. If the secret expires before it is replaced, streaming stops, so add the expiry date to your team's calendar and to the connector runbook. A certificate reduces the risk of a copied secret but still needs protected key storage and renewal. Sign-in activity appears in Entra logs under the app's service principal, which helps attribute writes to this connector. The main advantage is portability: an app registration works from any network that can reach Entra ID and Sentinel, including a self-hosted OpenCTI in your own data center.

A managed identity removes the stored secret from the connector configuration and from the rotation calendar. The trade-off is placement. Managed identities are available only to Azure resources that support them, so the connector must run on a supported Azure host, such as a virtual machine or a container or app service that supports managed identities. Verify the host types the connector package supports. If OpenCTI runs on premises or in another cloud, you would need a separate Azure-hosted component to run the connector, which adds a network path, an Azure resource and its patching to operate. Ownership also shifts: the identity's lifecycle follows the host, so decommissioning or recreating that host changes the identity and the role assignments attached to it.

Whichever option you choose, scope the permissions tightly. Grant access only to the single Sentinel workspace the connector writes to or reads from, and only to the actions the connector needs, such as uploading indicators or reading incidents. Check which built-in Azure roles cover those actions in your tenant, and confirm whether a custom role is needed. Record the decision, the identity owner, the scope and the expiry or review date in your configuration records. Repeat the permission review whenever the connector or OpenCTI version changes, because required actions can change between releases.

Securing the Sentinel credentials and the indicator flow

Hardening this integration means protecting three things: the Entra credential that lets OpenCTI write indicators, the connector settings that govern what leaves OpenCTI, and the inbound path that brings Sentinel incidents back. The cards below cover each control, from credential storage and rotation to filtering, identity scope and activity review. Confirm each step in your own environment before enabling live traffic.

Store and rotate the Entra credential

Keep the Entra client secret or certificate in the secret store the OpenCTI platform uses, never in plain connector fields or shared notes. Set a rotation date before go-live and record who can rotate it. Plan revocation as well: know how to disable the app registration or credential quickly if a connector host is compromised, and confirm the steps with your Entra administrators before the first run.

Restrict who reads connector configuration

Connector settings hold workspace details, identity references and filter rules, so treat them as sensitive. Limit read and edit rights on connector configuration to the platform administrators who run the integration, and keep that group separate from analysts who only use intelligence. Review membership on a schedule and after staff changes. Confirm with your OpenCTI administrators how connector configuration is exposed to other users in your version.

Scope the identity to one workspace

Grant the Entra identity access only to the single Sentinel workspace that receives indicators and returns incidents. Check which role the Upload Indicators API call requires, and assign no broader role for convenience. Test with a sample indicator set and confirm that other workspaces in the tenant reject the same credential. Document the scope so an auditor can match it to the connector configuration.

Filter outbound indicators by TLP and labels

Only indicators that your sharing policy allows should leave OpenCTI. Define the TLP markings and labels that qualify for Sentinel, and apply that filter in the stream configuration so restricted or internal-only items never reach the workspace. Test the filter with indicators at each TLP level before enabling the live stream. Agree with the intelligence team who owns the label taxonomy, because a label filter only works when labels are applied consistently.

Limit inbound incident writes

The import of Sentinel incidents into OpenCTI creates intelligence objects from data written by another system, so accept those writes from one trusted connector identity only. Confirm which OpenCTI user or token the connector runs as, give it the minimum rights needed to create incident records, and keep it out of interactive use. Review which object types it creates and whether analysts can edit imported items. Check this against your change control process before enabling the inbound flow.

Log and review connector activity

Record what the connector sends, receives and changes, and review those records on a set schedule. OpenCTI Enterprise Edition includes activity monitoring and audit logs, and since OpenCTI 7.260224.0, defining and using authentication strategies, including SSO, is an Enterprise Edition feature. Ask the team to confirm whether this connector requires any Enterprise feature, and which log sources cover connector runs if you do not license Enterprise Edition.

How to verify indicators and incidents flow correctly

Define what passing looks like before you send a single test indicator. Write down expected results for each check in a test record: the TLP marking and labels each seeded indicator should carry, the fields you expect to see in the Sentinel workspace, the expiry behavior you expect after a revocation, and the number of objects you expect after each restart. If the expected result is written after the test runs, a surprising outcome becomes a debate instead of a fail. Keep the record with the change ticket so the auditor or the next engineer can see what was decided in advance.

Seed a small, known set of test indicators in OpenCTI. Include a few with each TLP marking your connector filters are meant to handle, and give each one a distinct label so you can trace it. Confirm in the Microsoft Sentinel workspace that each indicator arrives with the expected threat indicator fields, including the confidence, valid-from and valid-until values and the tags you mapped. Then revoke one test indicator and an expired one in OpenCTI and confirm the change propagates. Check that the revoked or expired indicator is no longer active in Sentinel, and record how long the change took to appear so you can compare it with your own tolerance for stale intelligence.

Restart the connector deliberately and check for duplicate creation. Run the same seeded set through at least one restart of the stream or import connector and count the indicators in Sentinel afterward. Duplicates usually point to a missing external identifier, a changed indicator name, or a connector state file that was not persisted. Repeat the check after a restart of the whole OpenCTI platform, because the work queue and worker state can change what gets re-sent. Create a test incident in Sentinel, confirm it appears in OpenCTI, and compare its title, severity, status and mapped attributes against your mapping document.

Confirm that restricted data stays inside OpenCTI. Mark a test indicator with the most restrictive TLP marking your policy covers, then query the Sentinel workspace and the connector logs to confirm it never appears. Check the connector configuration as well, because a filter that is correct in the UI can still be overridden by an older configuration file. Ask your security team to sign off on this check, since it is the one most likely to matter during an incident review.

Review the connector logs and the OpenCTI work queue after the platform restart. Look for repeated authentication failures against the Entra app registration or managed identity, throttling responses from the Upload Indicators API, and messages that stay in the queue without being processed. Record any warnings and decide in advance which ones block acceptance. Confirm with Microsoft documentation and your own Sentinel tenant which API limits and token lifetimes apply, rather than assuming the values from a previous setup.

Why the Sentinel indicators stop arriving and how to fix them

This table lists the failures most often seen when indicators stop reaching Microsoft Sentinel or incidents stop returning to OpenCTI. Each row gives the likely cause, the first check to run and the evidence to collect before changing configuration. Work through the rows in order, since authentication and network problems can hide the others.

FailureLikely causeCheck firstEvidence to collect
Authentication errorsWrong tenant ID, client ID, or an expired client secret in the connector configurationCompare tenant ID, client ID and secret expiry in the Entra app registration with the connector settingsConnector log lines showing token request failures, timestamps, and the secret expiry date
Permission deniedThe app registration or managed identity lacks the workspace role needed to write indicatorsConfirm the role is assigned at the Sentinel workspace scope and that the identity is the one the connector usesAuthorization error text from the connector log and the role assignment list for the identity
Network or proxy blocksEgress firewall, proxy or DNS policy blocks calls from the connector host to Microsoft login and Sentinel endpointsTest outbound HTTPS from the connector container using the same proxy and DNS settingsTimeout or TLS errors in logs, proxy deny entries, and DNS resolution output from the host
Connector version mismatchThe connector build does not match the OpenCTI release line in use, so calls or expected fields failCompare the connector image tag with the platform version and its documented compatibilityPlatform version, connector image tag, and startup errors about missing fields or unexpected schema
Filters exclude all indicatorsLabel, TLP, score or indicator type filters are stricter than the data in scope, or values do not match caseRun the same filter in OpenCTI against a known indicator and test each condition separatelyExported filter configuration and the count of indicators matched by the same query in OpenCTI
Duplicate or stale indicators after revocationRevoked or expired indicators were not withdrawn in Sentinel when the source changed in OpenCTIPick one revoked indicator in OpenCTI and search for it in Sentinel by valueIndicator identifiers in both platforms, revocation timestamps, and connector state records
RabbitMQ or worker backlogToo few workers or a full queue delays the connector's writes behind other platform messagesCheck queue depth and consumer count in RabbitMQ, and compare worker count with OpenCTI's documented sizingQueue length over time, worker restarts, consumer counts, and the gap between indicator creation and Sentinel visibility
Incidents not importingSentinel incident fields have no matching OpenCTI entity type or required field mapping, so records are skippedChoose one incident that did not import and trace each field through the mappingSkipped-record messages in logs, the incident's field list from Sentinel, and the mapping version in use

Questions buyers ask about the OpenCTI and Microsoft Sentinel integration

How much does an OpenCTI and Microsoft Sentinel integration cost?

DeployOpen does not publish a price list. Each quote follows a written scope agreed before work starts, so the cost depends on what that scope includes. The main drivers are the number of indicator types and filters, the identity model (how the Entra app registration or managed identity is set up), the number of Sentinel workspaces, the scope of incident import back into OpenCTI, how mature your OpenCTI deployment is, and how deep the testing goes. Ask for a quote that lists each driver as its own line, so you can see what changes if scope moves. Software licensing is separate: the OpenCTI Community Edition is licensed under Apache License 2.0, while some features need the Enterprise Edition license. Ongoing upgrades, monitoring and testing are available as a retainer, priced from its own written scope.

What makes an OpenCTI to Sentinel integration project take longer?

Duration follows the factors that set the scope. The largest are the number of indicator types and filters, since each one needs mapping and review, the number of workspaces and tenants involved, and how much incident history you import. Your OpenCTI deployment matters too. A platform that already runs with its required dependencies in production starts faster than a new build. Security review of filters and TLP rules, along with your change approval cycle, often sets the calendar more than the technical work does. Ask for a proposal that shows the phases, the dependencies between them, and which phases wait on decisions from your team.

How long does an OpenCTI and Microsoft Sentinel integration take?

The length depends on the scope you agree, so this page does not give a fixed duration. Plan around the factors that set it: indicator types and filters, identity model, number of workspaces, incident import scope, OpenCTI maturity, and testing depth. Also account for access and approvals on your side, because Azure role assignments and security sign-off can hold up the start. A written scope should state the milestones, the test exit criteria and the go-live window. Ask the vendor to show which tasks depend on your team, and how long they expect each review step to take in your change process.

What access and people does DeployOpen need from our team?

Plan for four roles on your side. First, Azure and Entra admin access to set up the app registration or managed identity and to assign roles on the Sentinel workspace. Second, a workspace owner who can approve role assignments and confirm which Sentinel workspace receives indicators. Third, the OpenCTI admin, who handles connector configuration and credentials on the OpenCTI side. Fourth, security sign-off on which indicator types, filters and TLP markings may leave OpenCTI. A non-production OpenCTI instance and a test workspace make verification much safer. Confirm with your Azure team early which roles they can grant, because that step often decides when work can begin.

Can our internal team build the OpenCTI to Sentinel integration alone?

Yes, an internal team can do this alone if it has working skills in two areas. On the Azure side, it needs Sentinel, Entra ID and role assignment experience. On the OpenCTI side, it needs connector, token and filter administration. The team also needs time to confirm the connector version against the OpenCTI release it runs. Security sign-off on filters and TLP rules is required either way. The practical question is capacity and continuity: someone must own the configuration after go-live, handle credential rotation and review each upgrade. Teams with thin skills in either area, or with fixed deadlines, often bring in an outside partner for the build and then keep the work in-house.

Which OpenCTI version do I need for the Sentinel connector?

Confirm the minimum OpenCTI version in the connector documentation before you plan, because this page does not state it. OpenCTI uses date-based versions. Regular releases follow x.YYMMDD.z, and LTS releases follow x.YYMMDD.z-lts.n. Regular releases ship from daily to weekly. LTS releases arrive every six months and are supported for one year, which gives a six-month overlap between consecutive LTS lines. LTS builds require a specific LTS license key, and after a one-month stabilization they receive only critical bug and security fixes. Choose the release line that fits your upgrade plan, then test the connector against it in a non-production environment first.

Should we use an Entra app registration or a managed identity?

Choose based on where the connector runs and how your Azure team manages credentials. A managed identity avoids storing a client secret for the workload, but it works only where the connector runs on an Azure resource that supports it. An Entra app registration works in more places, but it needs a client secret or certificate that you must store, rotate and monitor. Check the supported options in the current Microsoft and connector documentation, since this page does not set them. Either way, grant the smallest role on the specific workspace, and document which identity owns each permission so that rotation and audits have a clear owner.

Does DeployOpen certify our Sentinel integration for compliance audits?

No. DeployOpen prepares systems, controls and evidence for compliance assessments, but it does not issue audit reports, attestations or certifications. Independent auditors and certification bodies make those decisions. For this integration, useful evidence includes the written scope, the role assignments and their owners, the filter and TLP rules with security sign-off, test results, and records of credential rotation and connector changes. Ask your auditor which of these artifacts they expect before the build starts, so the implementation produces them as part of normal operation.

How DeployOpen scopes, builds and supports the Sentinel integration

DeployOpen scopes the OpenCTI and Microsoft Sentinel integration as a fixed-scope engagement, with the written scope agreed before work starts. We build the connector configuration, identity setup and data filters inside your own cloud accounts or data centers, then test and document them for your operations team. Ongoing support, upgrades and continuous testing are available as a retainer.

How we scope

  • Written scope that names the OpenCTI version, Sentinel workspace and data flows before work starts
  • Indicator selection, entity types and TLP filters agreed with your threat intelligence team
  • Identity model chosen up front: Entra app registration or managed identity, with the reasons recorded

How we build

  • Confirm the OpenCTI platform and connector runtime are ready in your infrastructure
  • Configure the stream of indicators to Sentinel through the Upload Indicators API
  • Build the import of Sentinel incidents back into OpenCTI, with field mapping reviewed by analysts

How we hand over

  • Test indicator flow end to end, including rejected records, duplicates and expired indicators
  • Document configuration, secret locations, identity permissions and rollback steps for your team
  • Walk operations staff through monitoring, connector logs and common failure checks

How we support

  • Plan OpenCTI upgrades around the date-based release line and LTS branches you run
  • Retest the Sentinel integration after each platform or Sentinel API change you adopt
  • Ongoing support and continuous testing are available as a retainer, scoped in writing

Sources and further reading

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.