# Get full details for one API key
Source: https://docs.socdefenders.ai/api-reference/api-keys/get-full-details-for-one-api-key
https://socdefenders.ai/api/openapi.json get /api/v1/keys/{keyId}
Returns the full metadata + lightweight usage summary for one API key. For deep analytics (latency percentiles, status-code breakdown, time series), use the [usage endpoint](#operation/getAPIKeyUsage).
# List your API keys
Source: https://docs.socdefenders.ai/api-reference/api-keys/list-your-api-keys
https://socdefenders.ai/api/openapi.json get /api/v1/keys
Returns all API keys belonging to the authenticated user. Used by the SOC Defenders dashboard to populate the key-management UI.
**Auth**: Session cookie (browser), not Bearer token. Hit this from a logged-in fetch — programmatic Bearer access is not allowed for the keys endpoints (chicken-and-egg).
Each list item includes the key prefix (e.g. `sk_live_zIc8`) but **not** the full secret — full keys are only ever shown once at creation time. Use the prefix to identify keys in your code or telemetry.
# Mint a new API key
Source: https://docs.socdefenders.ai/api-reference/api-keys/mint-a-new-api-key
https://socdefenders.ai/api/openapi.json post /api/v1/keys
Generates a new API key. **The full secret is returned exactly once** — save it immediately; subsequent reads only return the prefix.
## Key naming convention
Use descriptive, deployment-aware names. Good examples:
- `prod-splunk-2026q2`
- `staging-sentinel`
- `tom-laptop-dev`
Bad examples that make audit trails useless:
- `key1`, `my key`, `test`
## Expiration
Pass `expires_in_days` for time-bounded keys (recommended for any key handed to a partner or CI system). Omit for keys that never expire. You can revoke at any time via DELETE.
## Tier and scopes
Tier inherits from your account subscription (free or pro). Scopes default to your tier's full set; the response includes them so you know what the key can do.
# Revoke an API key
Source: https://docs.socdefenders.ai/api-reference/api-keys/revoke-an-api-key
https://socdefenders.ai/api/openapi.json delete /api/v1/keys/{keyId}
Revokes an API key — requests made with it from this point on return `401 invalid_api_key`. **This action cannot be undone**: revoked keys cannot be reactivated; create a new key instead.
The optional `reason` field is stored for audit purposes and shown in the dashboard. Use it to track *why* keys were revoked (compromise, rotation, employee departure, etc.).
# Usage analytics and rate-limit budget for an API key
Source: https://docs.socdefenders.ai/api-reference/api-keys/usage-analytics-and-rate-limit-budget-for-an-api-key
https://socdefenders.ai/api/openapi.json get /api/v1/keys/{keyId}/usage
Detailed usage analytics for a specific API key, scoped to the authenticated user. Use this to:
- Detect runaway clients (which endpoint is burning your rate limit)
- Forecast tier upgrades (am I approaching the daily cap?)
- Triage support issues (what does my 4xx rate look like?)
- Bill teammates (per-key request volume)
## What's returned
- Request counts: total, successful (2xx/3xx), client error (4xx), server error (5xx)
- Success rate and average response time
- Latency percentiles: p50, p95, p99
- Rate limit usage: per-minute and per-day high-water mark
- Top endpoints by request count
- Status code distribution
- Daily time-series for the requested window
- 429 (rate-limit) breakdown by hour
This endpoint authenticates via session cookie (browser/UI), not API key. Use it from the SOC Defenders dashboard or a logged-in fetch.
# GET /api/v1/articles/{id} — single article with expansions
Source: https://docs.socdefenders.ai/api-reference/articles/get
Retrieve a single article by ID with all enrichment expansions: extracted IOCs, CVEs, threat actors, MITRE ATT&CK techniques, and an AI summary. Free tier.
Fetching an article by its ID returns the full record including all enrichment expansions computed by the SOC Defenders platform: extracted indicators of compromise, referenced CVEs, attributed threat actors, and mapped MITRE ATT\&CK techniques. An AI-generated summary is also included. This endpoint is available on the Free tier.
## Endpoint
**Method:** `GET https://socdefenders.ai/api/v1/articles/{id}`
**Authentication:** Required — pass your API key in the `Authorization` header as a Bearer token.
**Tier:** Free.
## Path parameters
The UUID of the article. You can obtain article IDs from the list endpoint at `GET /api/v1/articles`.
## Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/articles/d0d2789a-cf57-4bfc-aaa5-cf9111a08f1c"
```
## Example response
```json theme={null}
{
"id": "d0d2789a-cf57-4bfc-aaa5-cf9111a08f1c",
"title": "Example Security Article",
"url": "https://example.com/article",
"source": "bleepingcomputer.com",
"published_at": "2024-01-15T10:00:00Z",
"summary": "AI-generated summary of the article content.",
"categories": ["vulnerabilities"],
"severity": "high",
"tags": ["#vulnerability", "#exploit"],
"iocs": [
{ "type": "ipv4", "value": "192.0.2.1" },
{ "type": "domain", "value": "evil.example.com" }
],
"cves": ["CVE-2024-1234"],
"threat_actors": ["APT28"],
"mitre_techniques": [
{ "id": "T1566", "name": "Phishing" }
],
"points": 3,
"comment_count": 2
}
```
## Response fields
Unique article UUID.
Article title as published by the source.
Canonical URL of the original article.
Domain of the publishing source, for example `bleepingcomputer.com` or `cisa.gov`.
ISO 8601 timestamp of when the article was published by the source.
AI-generated plain-text summary of the article content. Useful for triage without reading the full source.
Array of category labels, for example `["vulnerabilities", "ransomware"]`.
Assessed severity level: `critical`, `high`, `medium`, or `low`.
Array of extracted hashtag-style tags.
Array of indicators of compromise extracted from the article. Each object contains a `type` (e.g. `ipv4`, `domain`, `md5`, `sha256`, `url`) and a `value` string.
IOC type. Possible values: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `email`, `cve`.
The raw indicator value, for example an IP address string or domain name.
Array of CVE identifiers referenced in the article, for example `["CVE-2024-1234"]`.
Array of threat actor names attributed to or mentioned in the article, for example `["APT28", "Lazarus Group"]`.
Array of MITRE ATT\&CK techniques mapped to the article content.
MITRE ATT\&CK technique ID, for example `T1566`.
Human-readable technique name, for example `Phishing`.
Relevance or engagement score assigned to the article by the platform.
Number of community comments on the article within the SOC Defenders platform.
# GET /api/v1/articles — list threat intelligence articles
Source: https://docs.socdefenders.ai/api-reference/articles/list
Retrieve aggregated cybersecurity articles from 30+ feeds, with filtering, full-text search, cursor pagination, and IOC/CVE expansions. Free tier.
The articles endpoint aggregates cybersecurity news from 30+ sources — including CISA alerts, vendor advisories, and independent threat research — into a single paginated feed. You can filter by category, severity, threat actor, or MITRE technique, run full-text searches, and poll incrementally using the `since` parameter to retrieve only new content since your last request.
## Endpoint
**Method:** `GET https://socdefenders.ai/api/v1/articles`
**Authentication:** Required — pass your API key in the `Authorization` header as a Bearer token.
**Tier:** Free. Bulk export in NDJSON or CSV format requires a Pro subscription.
## Query parameters
Full-text search query. Matches against article titles, summaries, and extracted tags.
Filter by article category. Common values: `vulnerabilities`, `malware`, `threat-intelligence`, `data-breaches`, `ransomware`.
Filter by severity level. Accepted values: `critical`, `high`, `medium`, `low`.
ISO 8601 timestamp. Returns only articles published after this time. Use for delta polling — see the note below.
Pagination cursor returned in `meta.next_cursor` from a previous response. Pass this value to retrieve the next page of results.
Number of results per page. Maximum is 100 on the Free tier and 1,000 on Pro.
When `true`, returns only articles that have extracted indicators of compromise (IOCs).
Filter by threat actor name, for example `APT28` or `Lazarus Group`.
Filter by targeted industry sector, for example `healthcare`, `finance`, or `energy`.
Filter by MITRE ATT\&CK technique ID, for example `T1566` (Phishing).
Response format. Accepted values: `json` (default), `ndjson`, `csv`. NDJSON and CSV bulk export require a Pro subscription.
## Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/articles?category=vulnerabilities&severity=critical&limit=30"
```
## Example response
```json theme={null}
{
"meta": {
"total": 15926,
"limit": 30,
"next_cursor": "cursor_abc123"
},
"data": [
{
"id": "d0d2789a-cf57-4bfc-aaa5-cf9111a08f1c",
"title": "Example Security Article Title",
"url": "https://example.com/article",
"source": "bleepingcomputer.com",
"published_at": "2024-01-15T10:00:00Z",
"categories": ["vulnerabilities"],
"severity": "high",
"tags": ["#vulnerability", "#exploit"],
"has_iocs": true,
"points": 3
}
]
}
```
## Response fields
Pagination metadata for the response.
Total number of articles matching the query across all pages.
The page size used for this response.
Opaque cursor for the next page. Pass this as the `cursor` query parameter to retrieve the following page. Absent when there are no more results.
Array of article objects matching the query.
Unique article UUID. Use this to fetch the full article with expansions via `GET /api/v1/articles/{id}`.
Article title as published by the source.
Canonical URL of the original article.
Domain of the publishing source, for example `bleepingcomputer.com` or `cisa.gov`.
ISO 8601 timestamp of when the article was published by the source.
Array of category labels assigned to the article, for example `["vulnerabilities", "ransomware"]`.
Assessed severity level: `critical`, `high`, `medium`, or `low`.
Array of extracted hashtag-style tags, for example `["#vulnerability", "#exploit"]`.
`true` if the article has at least one extracted indicator of compromise. Fetch the full article to retrieve the `iocs` array.
Relevance or engagement score assigned to the article by the platform.
## Delta polling
To continuously ingest new articles without re-fetching old ones, record the highest `published_at` value from each response and pass it as the `since` parameter on your next request. This returns only articles published after that timestamp, making it efficient to poll on a schedule.
```bash theme={null}
# First poll — fetch recent critical articles
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/articles?severity=critical&limit=100"
# Subsequent poll — only articles newer than your last result
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/articles?severity=critical&limit=100&since=2024-01-15T10:00:00Z"
```
# List, search, and bulk-export aggregated cybersecurity news
Source: https://docs.socdefenders.ai/api-reference/articles/list-search-and-bulk-export-aggregated-cybersecurity-news
https://socdefenders.ai/api/openapi.json get /api/v1/articles
The workhorse endpoint for the News API. One URL gives you list, filter, full-text search, delta polling, and bulk export — composed via query parameters.
## What it returns
A flat `Article` object per row. Every field is top-level (`source_name` not `source.name`) so streaming and CSV parsing are zero-friction. See the [Article](#model/Article) schema for the complete shape.
## Common use cases
### 1. Today's critical-severity vulnerabilities
```
GET /api/v1/articles?category=vulnerabilities&severity=critical&since=2026-05-17T00:00:00Z&limit=20
```
### 2. Delta poll for SIEM/SOAR sync (recommended pattern)
```
GET /api/v1/articles?time_field=modified_at&modified_since=&sort=modified:desc&limit=500
```
Persist the last `modified_at` you saw on each run; pass it back as `modified_since` on the next call. Use `X-Next-Cursor` to walk multi-page deltas.
### 3. Bulk NDJSON export with IOC expansions (Pro)
```
GET /api/v1/articles?format=ndjson&expand=iocs,mitre&has_iocs=true&limit=5000
```
Returns one homogeneous JSON object per line. Stream-parse with `for line in r: json.loads(line)`.
### 4. Threat-actor research feed
```
GET /api/v1/articles?threat_actor=lazarus,apt28&expand=threat_actors,iocs&limit=50
```
### 5. Industry-targeted intel (finance + healthcare)
```
GET /api/v1/articles?industry_tags=finance,healthcare&min_severity=7&sort=severity:desc
```
### 6. Sparse fields for high-volume polling
```
GET /api/v1/articles?fields=id,title,url,published_at&limit=100
```
Cuts payload by ~80% and reduces DB I/O proportionally.
## Tier behavior
| Tier | Lookback | Per-request cap | Formats |
|------|----------|-----------------|---------|
| Free | 7 days | 100 | JSON |
| Pro | 365 days | 1,000 (5,000 for export) | + NDJSON, CSV (requires `read:articles:export`) |
## Pagination
Use **cursor pagination** for any walk past 1,000 rows. The response contains `links.next` (full URL) and `X-Next-Cursor` (header) — pass either back as `?cursor=`. Offsets > 1000 are rejected with `deep_paging_unsupported`.
## Response signaling headers
| Header | When | Meaning |
|--------|------|---------|
| `X-Next-Cursor` | More pages exist | Opaque cursor for next page |
| `X-Tier-Lookback-Days` | Always | Effective lookback window for the caller's tier |
| `X-Tier-Lookback-Clamped` | `since` was clamped | Caller asked for older data than tier allows; clamped silently |
| `X-Limit-Capped` | `limit` exceeded tier cap | Caller's requested limit was reduced |
| `X-Format-Cost-Multiplier` | Always | Rate-limit cost multiplier for this format (NDJSON/CSV cost more) |
| `Deprecation` + `Sunset` | Legacy `?cve=` param used | Migrate to `cve_text_search` |
# Retrieve a single article with full expansions
Source: https://docs.socdefenders.ai/api-reference/articles/retrieve-a-single-article-with-full-expansions
https://socdefenders.ai/api/openapi.json get /api/v1/articles/{id}
Fetches one article by UUID with **all expansions enabled by default** (`iocs`, `cves`, `threat_actors`, `mitre`). Use `?expand=mitre` to opt out of the heavy expansions if you just need the article body.
## Common use cases
### 1. Article detail page (web UI)
Fetch everything in one request:
```
GET /api/v1/articles/e90ea8b7-8500-4a14-875c-1d64755c80ca
```
### 2. IOC enrichment workflow
Click-through from an IOC search to the source article's full context:
```
GET /api/v1/articles/{id}?expand=iocs,threat_actors
```
### 3. Minimal lookup (just the body)
```
GET /api/v1/articles/{id}?expand=mitre&fields=id,title,url,ai_summary,severity_score
```
## Errors
| Status | Code | Meaning |
|--------|------|---------|
| 400 | `invalid_parameter` | id is not a valid UUID |
| 403 | `lookback_exceeded` | Article exists but published before your tier's lookback window |
| 404 | `article_not_found` | No article with that UUID |
| 410 | `article_archived` | Article was archived. Pass `?include_archived=true` to retrieve it anyway |
Responses are cached for 60 seconds (`Cache-Control: public, s-maxage=60, stale-while-revalidate=120`).
# API key authentication for the SOC Defenders API
Source: https://docs.socdefenders.ai/api-reference/authentication
Authenticate every SOC Defenders API request with an API key. Pass it as a Bearer token or X-API-Key header. Keys are managed in Settings → API Keys.
Every request to the SOC Defenders API must include a valid API key. You pass the key in an HTTP request header — either as a Bearer token in the `Authorization` header or directly in the `X-API-Key` header. Both methods are equivalent; use whichever fits your tooling or integration.
## Getting an API key
To generate an API key, sign in to SOC Defenders and go to **Settings → API Keys**. Click **Create key**, give it a name, and copy the value — it is shown only once.
* **Free tier**: create up to 3 API keys
* **Pro tier**: create up to 50 API keys
All keys follow the format `sk_live_...`.
## Passing your key in a request
### Authorization header (Bearer token)
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs?type=ipv4&limit=10"
```
### X-API-Key header
```bash theme={null}
curl -H "X-API-Key: sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs?type=ipv4&limit=10"
```
Both headers are accepted on every endpoint. You do not need to use both at the same time.
## Authentication errors
If your key is missing, malformed, or invalid, the API returns a `401 Unauthorized` response with a JSON error body.
**Missing key**
```json theme={null}
{
"error": {
"code": "missing_api_key",
"message": "API key is required. Include it in the Authorization header as \"Bearer sk_live_...\" or in the X-API-Key header.",
"request_id": "req_..."
}
}
```
### Error code reference
| Code | Description | Fix |
| ----------------- | ------------------------------------------------------ | ------------------------------------------------------------------------------ |
| `missing_api_key` | No API key was included in the request | Add the `Authorization: Bearer sk_live_...` or `X-API-Key` header |
| `invalid_api_key` | The key was provided but does not match any active key | Check for typos or extra whitespace; verify the key in **Settings → API Keys** |
| `expired_api_key` | The key has been deactivated or expired | Generate a new key in **Settings → API Keys** and update your integration |
## Security best practices
Never include your API key in a URL query parameter. Query strings appear in server logs, browser history, and referrer headers, which exposes your key to unintended parties. Always pass the key in a request header.
* Store keys in environment variables or a secrets manager, not in source code.
* Use one key per integration so you can rotate or revoke individual keys without disrupting others.
* If a key is compromised, delete it immediately in **Settings → API Keys** and replace it with a new one.
* On the Pro tier, take advantage of your 50-key limit to scope keys by team, environment, or service.
# Generate deployable Sigma detection rules
Source: https://docs.socdefenders.ai/api-reference/detection-rules/generate-deployable-sigma-detection-rules
https://socdefenders.ai/api/openapi.json get /api/v1/iocs/sigma
Generates ready-to-deploy [Sigma](https://github.com/SigmaHQ/sigma) detection rules from recent IOCs.
## What you get
Multi-document YAML (`text/yaml`) — one rule per IOC, separated by `---`:
- **network_connection** logsource for IPv4/IPv6 (matches `DestinationIp`)
- **dns** logsource for domains (matches `QueryName`)
- **proxy** logsource for URLs (matches `c-uri`)
- **process_creation** logsource for file hashes (matches `Hashes`)
## Why deterministic IDs
Every rule's UUID is derived deterministically from the IOC value + type. Re-running this endpoint with overlapping IOCs produces the **same rule IDs**, so your SIEM rule repo doesn't churn version control history when you periodically refresh the feed.
## Convert to your SIEM's native language
The output is vanilla Sigma — use `sigma convert` to target Splunk SPL, Elasticsearch DSL, Sentinel KQL, etc.:
```bash
curl ... -o socdefenders.yml
sigma convert -t splunk socdefenders.yml > rules.spl
```
Requires the **Pro plan** (`read:iocs` scope).
# Export IOCs as a STIX 2.1 bundle
Source: https://docs.socdefenders.ai/api-reference/export-formats/export-iocs-as-a-stix-21-bundle
https://socdefenders.ai/api/openapi.json get /api/v1/iocs/stix
Generates a STIX 2.1 bundle of Indicator SDOs (Structured Data Objects) for direct download. Use this when you want a one-shot bundle; for streaming/polling integrations use the [TAXII 2.1 endpoints](#tag/TAXII) instead.
## Bundle structure
```
bundle
├── identity (SOC Defenders, optional)
├── marking-definition (TLP, optional)
└── indicator × N
```
Each `indicator` SDO carries:
- A STIX 2.1 pattern (e.g. `[ipv4-addr:value = '1.2.3.4']`)
- TLP marking (mapped from our confidence: high→green, medium→amber, low→clear, or override with `tlp=`)
- Tags as STIX `labels`
- MITRE references via `kill_chain_phases`
## TLP markings
By default, indicators are tagged with TLP based on their confidence. Override with `tlp=`:
- `clear`: share freely (low confidence)
- `green`: share within community (high confidence indicators by default)
- `amber`: limited distribution
- `amber+strict`: amber + need-to-know
- `red`: do not share
## Splunk ES / Sentinel ingestion
Both platforms accept STIX bundles via their threat-intel connectors. Download with `format=bundle` (default) and upload via their UI/API.
Requires the **Pro plan** (`read:stix` scope).
# Export IOCs as CEF or RFC 5424 Syslog events
Source: https://docs.socdefenders.ai/api-reference/export-formats/export-iocs-as-cef-or-rfc-5424-syslog-events
https://socdefenders.ai/api/openapi.json get /api/v1/iocs/cef
Stream IOCs as either CEF (Common Event Format, ArcSight-compatible) or RFC 5424 Syslog. Designed to be piped into a SIEM ingestion pipeline.
## Output
- `format=cef` (default): One CEF line per IOC. Example header: `CEF:0|SOCDefenders|ThreatIntel|1.0|ipv4|Malicious IPv4|6|src=192.168.1.1 ...`
- `format=syslog`: RFC 5424 lines with structured-data sections.
## Ingestion examples
- **Splunk**: configure a TCP/UDP listener on port 514 and `curl ... | nc splunk.example.com 514`
- **Sentinel**: forward via Logstash + Common Event Format connector
- **rsyslog**: pipe directly with `logger -p local0.info -t socdefenders`
Requires the **Pro plan** (`read:cef` scope).
# Export IOCs as Mandiant OpenIOC 1.0 XML
Source: https://docs.socdefenders.ai/api-reference/export-formats/export-iocs-as-mandiant-openioc-10-xml
https://socdefenders.ai/api/openapi.json get /api/v1/iocs/openioc
Generates an [OpenIOC 1.0](https://github.com/mandiant/OpenIOC_1.0) XML document — the format Mandiant introduced and still used by FireEye HX, several EDR products, and some commercial threat intel tools.
## Output structure
```xml
...
malicious.com
...
```
## Import targets
- **Mandiant HX**: Configuration → Indicators → Import OpenIOC
- **FireEye products**: Same UI path
- **Stix-shifter**: `stix-shifter translate openioc query ...`
Requires the **Pro plan** (`read:openioc` scope).
# Export IOCs as MISP JSON event
Source: https://docs.socdefenders.ai/api-reference/export-formats/export-iocs-as-misp-json-event
https://socdefenders.ai/api/openapi.json get /api/v1/iocs/misp
Export IOCs as a MISP-format JSON event ready for import into the [MISP threat intelligence platform](https://www.misp-project.org/).
## What you get
A single MISP `Event` object containing one `Attribute` per IOC. Attribute types are mapped from our internal types:
| SOC Defenders type | MISP type |
|---|---|
| ipv4 | ip-src |
| ipv6 | ip-src |
| domain | domain |
| url | url |
| md5, sha1, sha256, sha512 | matching hash type |
| email | email-src |
| cve | vulnerability |
## Import to MISP
```bash
curl -X POST https://your-misp.example.com/events/add \
-H "Authorization: " \
-H "Content-Type: application/json" \
-d @socdefenders-misp.json
```
Requires the **Pro plan** (`read:misp` scope).
# GET /api/v1/iocs — list indicators of compromise
Source: https://docs.socdefenders.ai/api-reference/iocs/list
Retrieve a paginated list of IOCs filtered by type, category, confidence, industry, and time range. Returns JSON with meta and data fields. Free tier.
The `/api/v1/iocs` endpoint returns a paginated list of indicators of compromise from the SOC Defenders feed. You can narrow results by IOC type, confidence level, source category, industry sector, and time range. Use the `since` parameter for delta polling to retrieve only indicators added after a given timestamp — useful for keeping your SIEM or TIP synchronized without re-fetching the full feed.
## Request
**Method:** `GET`\
**URL:** `https://socdefenders.ai/api/v1/iocs`\
**Auth:** Required — `Authorization: Bearer sk_live_YOUR_KEY`\
**Tier:** Free (up to 100 results per request; Pro raises this to 10,000)
## Query parameters
Filter by IOC type. One of: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `mitre-attack`, `email`.
Filter by confidence level. One of: `high`, `medium`, `low`.
Filter by source category. Common values: `government`, `commercial`, `community`.
Filter by CISA sector name (e.g. `energy`, `healthcare`, `financial-services`).
ISO 8601 timestamp. Returns only IOCs added or updated after this time. Use for delta polling (e.g. `2024-01-01T00:00:00Z`).
Maximum number of results to return. Free tier: 100. Pro tier: up to 10,000.
Number of results to skip for pagination. Use with `limit` to page through large result sets.
## Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs?type=ipv4&confidence=high&limit=100"
```
## Response
```json theme={null}
{
"meta": { "total": 1523, "limit": 100, "offset": 0 },
"data": [
{
"type": "ipv4",
"value": "192.168.1.100",
"confidence": "high",
"source": {
"feed_name": "CISA Alerts",
"category": "government"
}
}
]
}
```
### Response fields
Pagination metadata for the response.
Total number of IOCs matching the applied filters, regardless of `limit`.
The `limit` value applied to this response.
The `offset` value applied to this response.
Array of IOC objects matching the query.
IOC type. One of: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `mitre-attack`, `email`.
The indicator value (e.g. an IP address, domain name, or file hash).
Feed confidence rating for this indicator: `high`, `medium`, or `low`.
Name of the source feed that reported this indicator (e.g. `CISA Alerts`).
Category of the source feed (e.g. `government`, `commercial`, `community`).
## Error responses
If your API key is missing or invalid, the API returns a `401 Unauthorized` response:
```json theme={null}
{
"error": {
"code": "missing_api_key",
"message": "API key is required. Include it in the Authorization header as \"Bearer sk_live_...\" or in the X-API-Key header.",
"request_id": "req_..."
}
}
```
See [Authentication](/api-reference/authentication) for the full error code reference.
# List IOCs (Indicators of Compromise)
Source: https://docs.socdefenders.ai/api-reference/iocs/list-iocs-indicators-of-compromise
https://socdefenders.ai/api/openapi.json get /api/v1/iocs
The primary IOC export endpoint. Returns indicators of compromise — IPs, domains, URLs, file hashes, email addresses, CVEs, and MITRE ATT&CK technique IDs — extracted from articles and ingested from threat feeds (URLhaus, Feodo Tracker, ThreatFox).
## What's an IOC?
An *Indicator of Compromise* is a forensic artifact that suggests a system has been compromised. The feed mixes:
- **Article-extracted IOCs**: pulled out of writeups by our extraction pipeline (`source.origin: "article"`)
- **Feed-sourced IOCs**: ingested directly from threat-intel feeds (`source.origin: "feed"`)
## Common use cases
### 1. SIEM block-list ingestion (recent IPs)
```
GET /api/v1/iocs?type=ipv4&confidence=high&since=2026-05-16T00:00:00Z&format=txt
```
Returns one IP per line — perfect for piping into a firewall block-list.
### 2. Hash IOCs for EDR detection
```
GET /api/v1/iocs?type=sha256&confidence=high&limit=1000
```
### 3. APT-tagged IOCs for threat hunting
```
GET /api/v1/iocs?industry=finance&since=2026-05-01T00:00:00Z&limit=500
```
### 4. CSV export for spreadsheet analysis
```
GET /api/v1/iocs?type=domain&format=csv&limit=1000
```
## Output formats
- `json` (default): structured response with metadata + pagination
- `csv`: 10-column CSV — id, type, value, confidence, first_seen, last_seen, source_article, source_feed, category, tags
- `txt`: bare IOC values one per line — for direct firewall/EDR ingestion
## Tier behavior
| Tier | Per request | Lookback | Formats |
|------|-------------|----------|---------|
| Free | 100 | 1 day | json only |
| Pro | 10,000 | 365 days | json, csv, txt |
## Pagination
Standard `offset` + `limit`. For walks past ~1k offsets, use the Articles endpoint pattern (cursor) or narrow your time window.
# GET /api/v1/lookup — enrich a single IOC
Source: https://docs.socdefenders.ai/api-reference/iocs/lookup
Enrich a single IP, domain, URL, or file hash with AI risk scoring, MITRE ATT&CK techniques, and auto-generated Splunk and KQL hunting queries. Free tier.
The `/api/v1/lookup` endpoint enriches a single indicator of compromise with contextual threat intelligence. For a given IP address, domain, URL, or file hash, it returns an AI-generated risk score, associated MITRE ATT\&CK techniques, the source feeds that have reported the indicator, and auto-generated detection queries ready to deploy in Splunk or Microsoft Sentinel. Use this endpoint for on-demand triage during an investigation or to enrich alerts in your SOAR playbook.
## Request
**Method:** `GET`\
**URL:** `https://socdefenders.ai/api/v1/lookup`\
**Auth:** Required — `Authorization: Bearer sk_live_YOUR_KEY`\
**Tier:** Free
## Query parameters
The indicator value to enrich (e.g. `192.0.2.1`, `evil.com`, a file hash).
IOC type hint for disambiguation. One of: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `mitre-attack`, `email`. Providing this speeds up resolution when a value is ambiguous.
## Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/lookup?value=192.0.2.1&type=ipv4"
```
## Response
```json theme={null}
{
"value": "192.0.2.1",
"type": "ipv4",
"risk_score": "high",
"confidence": "high",
"mitre_techniques": [
{
"id": "T1071",
"name": "Application Layer Protocol"
},
{
"id": "T1041",
"name": "Exfiltration Over C2 Channel"
}
],
"hunting_queries": {
"splunk": "index=* dest_ip=\"192.0.2.1\" | stats count by src_ip, dest_ip, dest_port | sort -count",
"kql": "NetworkCommunicationEvents | where RemoteIP == \"192.0.2.1\" | summarize count() by LocalIP, RemoteIP, RemotePort"
},
"sources": [
{
"feed_name": "CISA Alerts",
"category": "government"
},
{
"feed_name": "Emerging Threats",
"category": "community"
}
]
}
```
### Response fields
The indicator value that was queried.
The detected or specified IOC type (e.g. `ipv4`, `domain`, `sha256`).
AI-generated risk rating for this indicator. One of: `critical`, `high`, `medium`, `low`.
Confidence level assigned by the source feed(s). One of: `high`, `medium`, `low`.
MITRE ATT\&CK techniques associated with this indicator.
MITRE ATT\&CK technique ID (e.g. `T1071`).
Human-readable technique name (e.g. `Application Layer Protocol`).
Auto-generated detection queries for common SIEM platforms.
SPL (Search Processing Language) query for Splunk.
KQL (Kusto Query Language) query for Microsoft Sentinel or Microsoft Defender.
List of source feeds that have reported this indicator.
Name of the source feed (e.g. `CISA Alerts`).
Category of the source feed (e.g. `government`, `commercial`, `community`).
## Error responses
If your API key is missing or invalid, the API returns a `401 Unauthorized` response:
```json theme={null}
{
"error": {
"code": "missing_api_key",
"message": "API key is required. Include it in the Authorization header as \"Bearer sk_live_...\" or in the X-API-Key header.",
"request_id": "req_..."
}
}
```
See [Authentication](/api-reference/authentication) for the full error code reference.
# GET /api/v1/iocs/search — search for a specific IOC
Source: https://docs.socdefenders.ai/api-reference/iocs/search
Search for a specific indicator value across the entire SOC Defenders IOC feed. Returns matching entries with enrichment data. Free tier.
The `/api/v1/iocs/search` endpoint lets you look up a specific indicator value — such as an IP address, domain, or file hash — across the entire SOC Defenders feed. Unlike the list endpoint, which filters by attributes, this endpoint matches against the indicator value itself. Use it when you have a specific observable and want to know whether the feed has seen it, and if so, with what confidence and from which sources.
## Request
**Method:** `GET`\
**URL:** `https://socdefenders.ai/api/v1/iocs/search`\
**Auth:** Required — `Authorization: Bearer sk_live_YOUR_KEY`\
**Tier:** Free
## Query parameters
The IOC value to search for. For example, an IP address (`1.2.3.4`), a domain (`evil.com`), or a file hash (`abc123...`).
Narrow the search to a specific IOC type. One of: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `mitre-attack`, `email`. Useful when a value could be interpreted as more than one type.
## Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs/search?q=evil-domain.com"
```
## Response
The response uses the same structure as `GET /api/v1/iocs`, filtered to entries that match the queried value:
```json theme={null}
{
"meta": { "total": 1, "limit": 100, "offset": 0 },
"data": [
{
"type": "domain",
"value": "evil-domain.com",
"confidence": "high",
"source": {
"feed_name": "CISA Alerts",
"category": "government"
}
}
]
}
```
### Response fields
Pagination metadata for the response.
Total number of matching IOC entries across all sources.
The `limit` value applied to this response.
The `offset` value applied to this response.
Array of IOC objects matching the queried value.
IOC type. One of: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `mitre-attack`, `email`.
The indicator value that was matched.
Feed confidence rating: `high`, `medium`, or `low`.
Name of the source feed that reported this indicator.
Category of the source feed (e.g. `government`, `commercial`, `community`).
## Error responses
If your API key is missing or invalid, the API returns a `401 Unauthorized` response:
```json theme={null}
{
"error": {
"code": "missing_api_key",
"message": "API key is required. Include it in the Authorization header as \"Bearer sk_live_...\" or in the X-API-Key header.",
"request_id": "req_..."
}
}
```
See [Authentication](/api-reference/authentication) for the full error code reference.
# Search for a specific IOC value
Source: https://docs.socdefenders.ai/api-reference/iocs/search-for-a-specific-ioc-value
https://socdefenders.ai/api/openapi.json get /api/v1/iocs/search
Look up a specific IOC (IP, domain, hash, URL, CVE, etc.) and get back every record from across the feed plus related indicators from the same article or campaign.
## Strategy
Two-stage lookup:
1. **Exact match** against `ioc_value_normalized` (btree-indexed, ~5ms). Lowercased + URL-canonicalized + IPv6-zero-compressed.
2. **Trigram fallback** if no exact match. Requires ≥3 characters and uses the `pg_trgm` GIN index on the value column.
## Use cases
- **Triage**: pasted IP from an alert → "is this in our threat intel?"
- **Pivot**: found a hash → fetch the article + the other IOCs from the same report
- **Verification**: confirm a domain hasn't been flagged elsewhere
## Related IOCs
When `include_related=true` (default), the response includes up to 10 IOCs from the same source article. Useful for hash → campaign expansion.
# GET /api/v1/iocs/sigma — generate Sigma detection rules
Source: https://docs.socdefenders.ai/api-reference/iocs/sigma
Export current IOCs as deployable Sigma YAML detection rules, one per indicator. Compatible with any SIEM that supports Sigma. Requires Pro.
The `/api/v1/iocs/sigma` endpoint exports IOCs from the SOC Defenders feed as multi-document Sigma YAML — one detection rule per indicator. Each rule targets a specific log source and detection pattern for the corresponding IOC type, and includes MITRE ATT\&CK tags where applicable. The output is compatible with `sigmac`, `pySigma`, and any SIEM that supports the Sigma standard, including Splunk, Microsoft Sentinel, Elastic, and QRadar. Apply filters to scope the export to a specific IOC type, time window, or confidence level.
## Request
**Method:** `GET`\
**URL:** `https://socdefenders.ai/api/v1/iocs/sigma`\
**Auth:** Required — `Authorization: Bearer sk_live_YOUR_KEY`\
**Tier:** Pro\
**Content-Type:** `application/yaml` (multi-document YAML)
This endpoint requires a Pro subscription. Requests made with a Free-tier key will receive a `403 Forbidden` response.
## Query parameters
Filter by IOC type. One of: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `mitre-attack`, `email`.
ISO 8601 timestamp. Returns rules only for IOCs added or updated after this time (e.g. `2024-01-01T00:00:00Z`).
Filter by confidence level. One of: `high`, `medium`, `low`.
Filter by CISA sector name (e.g. `energy`, `healthcare`, `financial-services`).
Maximum number of Sigma rules to return. Pro tier: up to 10,000.
## Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs/sigma?type=ipv4" \
-o ioc-rules.yml
```
## Response
The response body is a multi-document YAML file. Each YAML document (separated by `---`) is a complete, standalone Sigma rule for one IOC.
```yaml theme={null}
title: SOC Defenders IOC - Malicious IP 192.0.2.1
id:
status: experimental
description: Detects network connection to known malicious IP from SOC Defenders feed
references:
- https://socdefenders.ai
logsource:
category: network_connection
product: windows
detection:
selection:
DestinationIp: '192.0.2.1'
condition: selection
falsepositives:
- Unknown
level: high
tags:
- attack.command_and_control
```
### Rule fields
Human-readable rule title, including the IOC value.
Unique UUID for this Sigma rule. Stable across exports for the same IOC.
Rule maturity status. Exported rules are `experimental`.
Plain-text description of what the rule detects and its data source.
List of reference URLs. Always includes `https://socdefenders.ai`.
Sigma log source definition specifying the category and product the rule targets.
Log category (e.g. `network_connection`, `process_creation`, `dns`).
Target product or platform (e.g. `windows`, `linux`).
Sigma detection logic, including field-value match criteria and the condition expression.
Severity level for the rule. One of: `critical`, `high`, `medium`, `low`, `informational`.
MITRE ATT\&CK tags associated with the rule (e.g. `attack.command_and_control`).
## Error responses
If your API key is missing, invalid, or from a Free-tier account, the API returns an error response:
```json theme={null}
{
"error": {
"code": "missing_api_key",
"message": "API key is required. Include it in the Authorization header as \"Bearer sk_live_...\" or in the X-API-Key header.",
"request_id": "req_..."
}
}
```
See [Authentication](/api-reference/authentication) for the full error code reference.
# GET /api/v1/iocs/stats — IOC feed statistics
Source: https://docs.socdefenders.ai/api-reference/iocs/stats
Retrieve total IOC counts broken down by type, category, and source feed for analytics dashboards and monitoring. Requires Pro subscription.
The `/api/v1/iocs/stats` endpoint returns aggregate counts of all IOCs in the SOC Defenders feed, broken down by indicator type, source category, and named feed. Use it to build monitoring dashboards, track feed health over time, or verify that your ingestion pipeline is receiving the expected volume of indicators.
## Request
**Method:** `GET`\
**URL:** `https://socdefenders.ai/api/v1/iocs/stats`\
**Auth:** Required — `Authorization: Bearer sk_live_YOUR_KEY`\
**Tier:** Pro
This endpoint requires a Pro subscription. Requests made with a Free-tier key will receive a `403 Forbidden` response.
## Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs/stats"
```
## Response
```json theme={null}
{
"totals": {
"by_type": {
"ipv4": 48210,
"ipv6": 3120,
"domain": 29845,
"url": 11503,
"md5": 8760,
"sha1": 6340,
"sha256": 9210,
"cve": 4120,
"mitre-attack": 890,
"email": 2100
},
"by_category": {
"government": 32100,
"commercial": 51200,
"community": 40798
},
"by_source": {
"CISA Alerts": 12400,
"Emerging Threats": 23100,
"Abuse.ch": 18600
}
},
"last_updated": "2024-01-15T10:00:00Z"
}
```
### Response fields
Aggregate IOC counts broken down across multiple dimensions.
Count of IOCs per indicator type. Keys correspond to IOC types: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `mitre-attack`, `email`. Values are integers.
Count of IOCs per source category (e.g. `government`, `commercial`, `community`). Values are integers.
Count of IOCs per named source feed (e.g. `CISA Alerts`, `Emerging Threats`). Values are integers.
ISO 8601 timestamp of the most recent feed update (e.g. `2024-01-15T10:00:00Z`).
## Error responses
If your API key is missing, invalid, or from a Free-tier account, the API returns an error response:
```json theme={null}
{
"error": {
"code": "missing_api_key",
"message": "API key is required. Include it in the Authorization header as \"Bearer sk_live_...\" or in the X-API-Key header.",
"request_id": "req_..."
}
}
```
See [Authentication](/api-reference/authentication) for the full error code reference.
# GET /api/v1/iocs/stix — export as STIX 2.1 bundle
Source: https://docs.socdefenders.ai/api-reference/iocs/stix
Download current IOCs as a STIX 2.1 bundle containing Indicator and Identity objects. Supports the same filters as the main IOC endpoint. Requires Pro.
The `/api/v1/iocs/stix` endpoint exports IOCs from the SOC Defenders feed as a STIX 2.1 bundle. The bundle contains an `identity` object representing SOC Defenders as the producing organization, followed by `indicator` objects — one per IOC — each with a STIX pattern, pattern type, and validity timestamp. This format is compatible with any STIX 2.1-aware platform, including threat intelligence platforms (TIPs), SIEMs, and sharing hubs. Apply the same filters as the list endpoint to scope the bundle to a specific type, time window, or confidence level.
## Request
**Method:** `GET`\
**URL:** `https://socdefenders.ai/api/v1/iocs/stix`\
**Auth:** Required — `Authorization: Bearer sk_live_YOUR_KEY`\
**Tier:** Pro\
**Content-Type:** `application/json` (STIX bundle)
This endpoint requires a Pro subscription. Requests made with a Free-tier key will receive a `403 Forbidden` response.
## Query parameters
Filter by IOC type. One of: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `mitre-attack`, `email`.
ISO 8601 timestamp. Returns only IOCs added or updated after this time (e.g. `2024-01-01T00:00:00Z`). Use for incremental exports.
Filter by confidence level. One of: `high`, `medium`, `low`.
Filter by CISA sector name (e.g. `energy`, `healthcare`, `financial-services`).
Maximum number of indicator objects to include in the bundle. Pro tier: up to 10,000.
## Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs/stix?type=ipv4&since=2024-01-01T00:00:00Z"
```
## Response
The response is a STIX 2.1 bundle object. The `objects` array always begins with an `identity` object for SOC Defenders, followed by `indicator` objects for each matching IOC.
```json theme={null}
{
"type": "bundle",
"spec_version": "2.1",
"id": "bundle--...",
"objects": [
{
"type": "identity",
"spec_version": "2.1",
"id": "identity--...",
"name": "SOC Defenders"
},
{
"type": "indicator",
"spec_version": "2.1",
"id": "indicator--...",
"pattern": "[ipv4-addr:value = '192.0.2.1']",
"pattern_type": "stix",
"valid_from": "2024-01-15T10:00:00Z"
}
]
}
```
### Response fields
Always `bundle`.
STIX specification version. Always `2.1`.
Unique STIX identifier for this bundle (e.g. `bundle--`).
Array of STIX objects. The first object is always an `identity` for SOC Defenders; subsequent objects are `indicator` objects.
`identity` for the producing organization object.
`SOC Defenders`.
`indicator` for each IOC object.
STIX pattern expression for the indicator (e.g. `[ipv4-addr:value = '192.0.2.1']`).
Always `stix`.
ISO 8601 timestamp when this indicator became valid.
## Error responses
If your API key is missing, invalid, or from a Free-tier account, the API returns an error response:
```json theme={null}
{
"error": {
"code": "missing_api_key",
"message": "API key is required. Include it in the Authorization header as \"Bearer sk_live_...\" or in the X-API-Key header.",
"request_id": "req_..."
}
}
```
See [Authentication](/api-reference/authentication) for the full error code reference.
# Single-IOC enrichment with AI risk + hunting queries
Source: https://docs.socdefenders.ai/api-reference/lookup/single-ioc-enrichment-with-ai-risk-+-hunting-queries
https://socdefenders.ai/api/openapi.json get /api/v1/lookup
VirusTotal-style enrichment for one indicator. Auto-detects the type from the value (no need to pass `type=` unless overriding).
## What you get
- **Aggregated source reports**: every feed that has seen this indicator
- **First/last seen** timestamps across all sources
- **Confidence** (high/medium/low) — calculated from source reputation + recency
- **Tags + malware family** (when available)
- **MITRE ATT&CK techniques** referenced in the source articles
- **AI risk score** (0-100) and risk level
- **Hunting queries**: ready-to-paste Splunk SPL and Sentinel KQL
## When `found: false`
A "not found" response is **not** "this is safe" — it just means we have no record. Combine with reputation services (VT, GreyNoise, etc.) for negative conclusions.
## Common use cases
### 1. SOC triage (paste the alert IP)
```
GET /api/v1/lookup?ioc=110.36.30.112
```
### 2. Hash triage from sandbox detonation
```
GET /api/v1/lookup?ioc=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
```
### 3. CVE risk assessment
```
GET /api/v1/lookup?ioc=CVE-2024-12345
```
Returns CVE + recent articles mentioning it (proxy for "is this actively exploited").
### 4. Auto-type-detect override
```
GET /api/v1/lookup?ioc=internal.example.com&type=domain
```
Avoids ambiguous detection for short or unusual strings.
Available on the **Free plan** with standard 10 req/min limit.
# SOC Defenders REST API overview
Source: https://docs.socdefenders.ai/api-reference/overview
The SOC Defenders API provides programmatic access to IOC feeds, article aggregation, CVE data, and TAXII threat intelligence. Base URL and available endpoints.
The SOC Defenders REST API gives you programmatic access to aggregated threat intelligence from 30+ cybersecurity sources. You can retrieve IOCs, query enriched articles, export data in industry-standard formats (STIX 2.1, MISP, CEF, OpenIOC, Sigma), and poll a TAXII 2.1 server — all over HTTPS using JSON responses.
## Base URL
All API requests go to:
```
https://socdefenders.ai
```
Version 1 endpoints are available under the `/api/v1/` path prefix. For example:
```
https://socdefenders.ai/api/v1/iocs
```
## Response format
All endpoints return JSON by default. Some endpoints support alternative output formats (such as STIX 2.1 bundles, MISP events, or Sigma YAML) — these are noted in the individual endpoint references.
## Authentication
Every request requires an API key. Pass it as a Bearer token in the `Authorization` header or in the `X-API-Key` header. See [Authentication](/api-reference/authentication) for details.
## Available endpoints
| Endpoint | Tier | Description |
| --------------------------- | ---- | -------------------------------------------------------------------------------- |
| `GET /api/v1/iocs` | Free | List IOCs with filtering by type, category, confidence, date range, and industry |
| `GET /api/v1/iocs/search` | Free | Find a specific IOC value across the feed |
| `GET /api/v1/lookup` | Free | Single-IOC enrichment with AI risk score, MITRE techniques, and hunting queries |
| `GET /api/v1/articles` | Free | Aggregated news articles with full-text search, filters, and delta polling |
| `GET /api/v1/articles/{id}` | Free | Single article with IOC, CVE, threat actor, and MITRE technique expansions |
| `GET /api/v1/iocs/stats` | Pro | IOC totals broken down by type, category, and source |
| `GET /api/v1/iocs/stix` | Pro | STIX 2.1 bundle containing indicators and identity objects |
| `GET /api/v1/iocs/misp` | Pro | MISP JSON event |
| `GET /api/v1/iocs/cef` | Pro | CEF/Syslog stream for SIEM ingestion |
| `GET /api/v1/iocs/openioc` | Pro | OpenIOC XML document |
| `GET /api/v1/iocs/sigma` | Pro | Multi-document Sigma YAML detection rules per IOC |
| `GET /api/taxii2/` | Pro | TAXII 2.1 discovery — API roots and server metadata |
For limits on results per request, lookback periods, and request quotas by tier, see [Rate limits](/api-reference/rate-limits).
## OpenAPI specification
The machine-readable OpenAPI spec is available at:
```
https://socdefenders.ai/api/openapi.json
```
You can import it into Postman, Insomnia, or any OpenAPI-compatible tooling to explore and test the API interactively.
# API pricing and subscription tiers
Source: https://docs.socdefenders.ai/api-reference/pricing
SOC Defenders offers a Free tier with 1,000 requests/day and a Pro subscription at $299/month with 1M requests/day, STIX, TAXII, MISP, and all export formats.
SOC Defenders is available on two tiers: a Free plan for getting started and personal projects, and a Pro subscription for security teams and organizations that need higher throughput, longer lookback, and access to all export formats.
To start a free trial or upgrade to Pro, visit [socdefenders.ai/export](https://socdefenders.ai/export).
## Free tier
The Free tier is available at no cost and requires no credit card.
* **Price**: Free
* **Rate limit**: 10 requests/minute, 1,000 requests/day
* **IOC lookback**: 1 day
* **Article lookback**: 7 days
* **Results per request**: up to 100
* **Export formats**: JSON IOC export and paginated news articles
* **API keys**: up to 3
* **Support**: community support
## Pro tier
The Pro tier is designed for SOC analysts, security engineers, and teams that integrate threat intelligence into production pipelines.
* **Price**: $299/month, or $2,990/year (\$249/month)
* **Rate limit**: 1,000 requests/minute, 1,000,000 requests/day
* **Lookback period**: 365 days (IOCs and articles)
* **Results per request**: up to 10,000
* **Export formats**: all formats — STIX 2.1, TAXII 2.1, MISP, CEF/Syslog, OpenIOC, and Sigma YAML detection rules
* **Statistics access**: full IOC stats by type, category, and source
* **API keys**: up to 50
* **Support**: priority email support
* **Uptime SLA**: 99.9%
## Tier comparison
| Feature | Free | Pro |
| ---------------------- | -------------------------------- | ------------------------ |
| Rate limit | 10/min, 1,000/day | 1,000/min, 1,000,000/day |
| Lookback period | 1 day (IOCs) / 7 days (articles) | 365 days |
| Results per request | 100 | 10,000 |
| JSON/CSV export | Yes | Yes |
| STIX 2.1 / TAXII 2.1 | — | Yes |
| MISP / CEF / OpenIOC | — | Yes |
| Sigma rules | — | Yes |
| Full statistics access | — | Yes |
| API keys | Up to 3 | Up to 50 |
| Support | Community | Priority email |
| Uptime SLA | — | 99.9% |
# Rate limits and request quotas
Source: https://docs.socdefenders.ai/api-reference/rate-limits
SOC Defenders enforces per-minute and per-day rate limits based on your subscription tier. Free allows 10 req/min; Pro allows 1,000 req/min.
SOC Defenders enforces rate limits to ensure consistent performance for all users. Limits apply per API key and reset on a rolling basis. If you exceed a limit, the API returns a `429 Too Many Requests` response until the window resets.
## Limits by tier
| Limit | Free | Pro |
| ------------------- | ------ | --------- |
| Requests per minute | 10 | 1,000 |
| Requests per day | 1,000 | 1,000,000 |
| Results per request | 100 | 10,000 |
| IOC lookback period | 1 day | 365 days |
| Article lookback | 7 days | 365 days |
If your use case requires higher throughput, a longer lookback period, or more results per request, upgrade to the Pro tier. See [Pricing](/api-reference/pricing) for details.
## Rate limit response headers
Every API response includes headers that tell you your current usage against the active limit:
| Header | Description |
| ----------------------- | --------------------------------------------------- |
| `X-RateLimit-Limit` | Maximum requests allowed in the current window |
| `X-RateLimit-Remaining` | Requests remaining in the current window |
| `X-RateLimit-Reset` | Unix timestamp (UTC) when the current window resets |
Monitor these headers in your integration to stay within your quota and back off proactively before hitting a limit.
## 429 Too Many Requests
When you exceed a rate limit, the API responds with:
```http theme={null}
HTTP/1.1 429 Too Many Requests
X-RateLimit-Limit: 10
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1716000060
```
```json theme={null}
{
"error": {
"code": "rate_limit_exceeded",
"message": "You have exceeded your request limit. Check the X-RateLimit-Reset header for when your quota resets.",
"request_id": "req_..."
}
}
```
Wait until the timestamp in `X-RateLimit-Reset` before retrying. Use exponential backoff for automated retry logic.
## Best practices
**Use the `since` parameter for delta polling.** Rather than re-fetching the full IOC or article feed on each run, pass a `since` timestamp to retrieve only records that have changed since your last successful request. This significantly reduces your daily request count.
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs?since=2026-05-17T00:00:00Z"
```
**Cache results locally.** If multiple services or team members query the same data, fetch it once and distribute from a local cache rather than issuing redundant API calls.
**Page efficiently.** Use the maximum `limit` your tier allows per request to retrieve more data in fewer calls.
# Aggregated IOC statistics and trends
Source: https://docs.socdefenders.ai/api-reference/statistics/aggregated-ioc-statistics-and-trends
https://socdefenders.ai/api/openapi.json get /api/v1/iocs/stats
Pre-computed aggregations over the entire IOC corpus. Backed by the `iocs_stats_cache` table (refreshed every 10 minutes via pg_cron) — sub-millisecond response time.
## What you get
- Total IOC count and total article count
- Breakdown by IOC type (ipv4, domain, hash, etc.)
- Breakdown by source feed
- Breakdown by category (news, research, threat-intel, vendor, government)
- Last 24h and last 7d trend
- Feed health (healthy / degraded / error)
- Top MITRE ATT&CK techniques
- Top CVEs
## Use cases
- **Dashboard tiles**: "23,541 indicators ingested in the last 24h"
- **Trend charts**: 7-day rolling counts for sparklines
- **Coverage analysis**: which sources contribute most volume
- **Health monitoring**: detect when a feed stops producing IOCs
## Cache headers
Response includes:
- `X-Cache-Updated-At`: when the cache was last refreshed
- `X-Cache-Age-Seconds`: how stale the data is (max ~600s)
- `X-Cache-Stale: true` if pg_cron missed its window
# GET /api/taxii2/api/collections — list TAXII collections
Source: https://docs.socdefenders.ai/api-reference/taxii/collections
List all available TAXII 2.1 collections on the SOC Defenders server, including all IOCs, IP-only, hash-only, and CVE collections. Requires Pro.
The collections endpoint returns all TAXII 2.1 collections available on the SOC Defenders server. Each collection groups STIX objects by indicator type — you can poll all IOCs at once, or target a specific collection such as IP addresses, file hashes, or CVEs depending on what your integration needs.
## Endpoint
**Method:** `GET https://www.socdefenders.ai/api/taxii2/api/collections/`
**Authentication:** Required — pass your API key in the `Authorization` header as a Bearer token.
**Tier:** Pro.
## Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://www.socdefenders.ai/api/taxii2/api/collections/"
```
## Example response
```json theme={null}
{
"collections": [
{
"id": "all-iocs",
"title": "All IOCs",
"description": "All indicators of compromise across all types",
"can_read": true,
"can_write": false,
"media_types": ["application/stix+json;version=2.1"]
},
{
"id": "ip-addresses",
"title": "IP Addresses",
"description": "IPv4 and IPv6 indicators only",
"can_read": true,
"can_write": false,
"media_types": ["application/stix+json;version=2.1"]
},
{
"id": "file-hashes",
"title": "File Hashes",
"description": "MD5, SHA1, and SHA256 file hash indicators",
"can_read": true,
"can_write": false,
"media_types": ["application/stix+json;version=2.1"]
},
{
"id": "cves",
"title": "CVEs",
"description": "CVE vulnerability indicators",
"can_read": true,
"can_write": false,
"media_types": ["application/stix+json;version=2.1"]
}
]
}
```
The collection IDs shown above are illustrative. Use the `id` values returned by your live response when constructing object requests.
## Response fields
Array of collection objects available on the server.
Unique collection identifier. Pass this as the `{id}` path parameter when fetching objects from `GET /api/taxii2/api/collections/{id}/objects/`.
Human-readable name of the collection.
Description of what indicator types or data this collection contains.
`true` if your API key has read access to this collection.
`true` if your API key has write access to this collection. SOC Defenders collections are read-only; this field will always be `false`.
Array of MIME types supported by this collection. SOC Defenders serves STIX 2.1 objects: `application/stix+json;version=2.1`.
## Next steps
Use a collection `id` to fetch its STIX objects at [GET /api/taxii2/api/collections//objects/](/api-reference/taxii/objects).
# Fetch STIX 2.1 objects from a TAXII collection
Source: https://docs.socdefenders.ai/api-reference/taxii/fetch-stix-21-objects-from-a-taxii-collection
https://socdefenders.ai/api/openapi.json get /api/taxii2/api/collections/{collectionId}/objects/
Returns a STIX 2.1 bundle of objects in the requested collection. This is the workhorse pull endpoint for TAXII clients.
## Pagination
TAXII pagination uses `added_after` + `limit` + the `X-TAXII-Date-Added-Last` response header. Save the response's `X-TAXII-Date-Added-Last` and pass it as `added_after` on the next request to walk forward without missing objects.
## Filtering
- `?type=indicator` — only Indicator SDOs (most common)
- `?match[type]=ipv4-addr` — narrow further by indicator subtype
- `added_after` is the **canonical** delta-poll mechanism. Don't use any other field.
## Rate cost
This endpoint has a 2.5× rate multiplier (it generates a full STIX bundle). Plan polling cadence accordingly.
# List available TAXII collections
Source: https://docs.socdefenders.ai/api-reference/taxii/list-available-taxii-collections
https://socdefenders.ai/api/openapi.json get /api/taxii2/api/collections/
Returns the set of TAXII collections (logical streams of STIX objects). Each collection has a stable UUID consumers reference when fetching objects.
## Collections available
| Collection | Contents |
|---|---|
| `all-iocs` | All IOCs regardless of type |
| `network` | IPs, domains, URLs |
| `hashes` | MD5/SHA1/SHA256/SHA512 |
| `cves` | CVE IDs with context |
| `high-confidence` | Only high-confidence IOCs across types |
| `recent-24h` | Anything seen in the last 24 hours |
| `apt` | IOCs tagged with known APT campaigns |
| `ransomware` | IOCs tagged with ransomware families |
# GET /api/taxii2/collections/{id}/objects — STIX objects
Source: https://docs.socdefenders.ai/api-reference/taxii/objects
Retrieve paginated STIX 2.1 objects from a named TAXII collection. Supports added_after for delta polling and limit for page size. Requires Pro subscription.
This endpoint returns paginated STIX 2.1 objects from a named collection. Use it to bulk-ingest indicators into your SIEM or TIP, or to poll incrementally for new objects using the `added_after` parameter. Each page is returned as a STIX bundle, and pagination is driven by response headers rather than a cursor in the response body.
## Endpoint
**Method:** `GET https://www.socdefenders.ai/api/taxii2/api/collections/{id}/objects/`
**Authentication:** Required — pass your API key in the `Authorization` header as a Bearer token.
**Tier:** Pro.
## Path parameters
Collection ID obtained from `GET /api/taxii2/api/collections/`. For example, `all-iocs`, `ip-addresses`, `file-hashes`, or `cves`.
## Query parameters
ISO 8601 timestamp. Returns only STIX objects added to the collection after this time. Use the value of the `X-TAXII-Date-Added-Last` response header from your previous request to poll incrementally.
Maximum number of STIX objects to return per page. The server may return fewer than the requested limit.
Pagination token. Use the value from the `X-TAXII-Date-Added-Last` response header as the `added_after` value on your next request to continue paginating through results.
## Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://www.socdefenders.ai/api/taxii2/api/collections/all-iocs/objects/?added_after=2024-01-01T00:00:00Z&limit=100"
```
## Example response
```json theme={null}
{
"type": "bundle",
"id": "bundle--...",
"spec_version": "2.1",
"objects": [
{
"type": "indicator",
"spec_version": "2.1",
"id": "indicator--...",
"created": "2024-01-15T10:00:00Z",
"modified": "2024-01-15T10:00:00Z",
"name": "Malicious IP 192.0.2.1",
"pattern": "[ipv4-addr:value = '192.0.2.1']",
"pattern_type": "stix",
"valid_from": "2024-01-15T10:00:00Z",
"indicator_types": ["malicious-activity"]
}
],
"more": true,
"next": "cursor_xyz789"
}
```
## Response fields
Always `bundle` — the STIX 2.1 bundle type.
Unique STIX bundle identifier in the format `bundle--`.
STIX specification version. Always `2.1`.
Array of STIX 2.1 indicator objects contained in this page.
STIX object type, typically `indicator`.
STIX spec version for this object, always `2.1`.
Unique STIX object identifier in the format `indicator--`.
ISO 8601 timestamp of when the STIX object was created.
ISO 8601 timestamp of when the STIX object was last modified.
Human-readable name for the indicator, for example `Malicious IP 192.0.2.1`.
STIX pattern expression describing the indicator, for example `[ipv4-addr:value = '192.0.2.1']`.
Pattern language used. Always `stix`.
ISO 8601 timestamp from which the indicator is considered valid.
Array of STIX indicator type labels, for example `["malicious-activity"]`.
`true` if additional pages of objects are available. Use the response headers to paginate.
Pagination token for the next page. Present only when `more` is `true`.
## Response headers
| Header | Description |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| `X-TAXII-Date-Added-First` | ISO 8601 timestamp of the earliest object added in this page. |
| `X-TAXII-Date-Added-Last` | ISO 8601 timestamp of the latest object added in this page. Pass this as `added_after` on your next request to avoid re-fetching objects. |
## Delta polling
Store the value of the `X-TAXII-Date-Added-Last` response header after each successful poll and pass it as `added_after` on your next request. This ensures you only receive objects that were added after your previous poll, preventing duplicate processing and reducing unnecessary data transfer.
```bash theme={null}
# Initial poll
curl -v -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://www.socdefenders.ai/api/taxii2/api/collections/all-iocs/objects/?limit=100" \
2>&1 | grep -E "(X-TAXII-Date-Added|^{)"
# Subsequent poll using the stored X-TAXII-Date-Added-Last value
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://www.socdefenders.ai/api/taxii2/api/collections/all-iocs/objects/?added_after=2024-01-15T10:00:00Z&limit=100"
```
# TAXII 2.1 server overview and discovery
Source: https://docs.socdefenders.ai/api-reference/taxii/overview
SOC Defenders provides a TAXII 2.1 server for automated threat feed polling. Discover the API root and available collections at /api/taxii2/.
SOC Defenders exposes a TAXII 2.1 server that allows you to integrate the threat intelligence feed directly into SIEM platforms, threat intelligence platforms (TIPs), and custom tooling using the industry-standard TAXII protocol. TAXII (Trusted Automated eXchange of Intelligence Information) is defined by OASIS and is natively supported by tools such as Splunk, Microsoft Sentinel, IBM QRadar, and OpenCTI. Objects are served in STIX 2.1 format.
TAXII 2.1 access requires a Pro subscription. Upgrade your account at [socdefenders.ai](https://socdefenders.ai) to enable this feature.
## Protocol overview
TAXII 2.1 organises threat data into **collections** — named groups of STIX objects such as all IOCs, IP addresses only, file hashes, or CVEs. Clients discover the server's API root, list available collections, and then poll individual collections for objects, optionally using the `added_after` parameter to retrieve only objects added since their last poll.
## Discovery endpoint
Send a GET request to the discovery URL to retrieve the server's title, description, contact information, and the API root URL you will use for all subsequent requests.
**Method:** `GET https://socdefenders.ai/api/taxii2/`
**Authentication:** Required — pass your API key in the `Authorization` header as a Bearer token.
**Tier:** Pro.
### Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/taxii2/"
```
### Example response
```json theme={null}
{
"title": "SOC Defenders TAXII Server",
"description": "Threat intelligence feed aggregating 30+ cybersecurity sources including CISA alerts, vendor advisories, and threat research",
"contact": "support@socdefenders.ai",
"default": "https://www.socdefenders.ai/api/taxii2/api/",
"api_roots": ["https://www.socdefenders.ai/api/taxii2/api/"]
}
```
## Response fields
Human-readable name of the TAXII server.
Description of the threat intelligence feed provided by this server.
Contact address for the server operator. Reach the SOC Defenders team at `support@socdefenders.ai`.
The default API root URL. Use this as the base URL for collections and object requests.
Array of API root URLs available on this server. Each root can have its own set of collections.
## API root
All collection and object requests are made under the API root returned in the discovery response:
```
https://www.socdefenders.ai/api/taxii2/api/
```
Proceed to [Collections](/api-reference/taxii/collections) to list the available collections, or to [Collection Objects](/api-reference/taxii/objects) to begin fetching STIX objects.
# TAXII 2.1 API root metadata
Source: https://docs.socdefenders.ai/api-reference/taxii/taxii-21-api-root-metadata
https://socdefenders.ai/api/openapi.json get /api/taxii2/api/
API root resource. Returns server limits + supported TAXII version. Required step before listing collections.
`max_content_length` is the limit on a single bundle response; pagination (`limit` + `next`) handles larger pulls. `available: true` indicates the root is open for use.
# TAXII 2.1 discovery endpoint
Source: https://docs.socdefenders.ai/api-reference/taxii/taxii-21-discovery-endpoint
https://socdefenders.ai/api/openapi.json get /api/taxii2/
Entry point for TAXII 2.1 clients. Returns server metadata + a list of API roots. This is the URL you give your TAXII client (Splunk ES, Microsoft Sentinel, OpenCTI, MISP TAXII module).
## What clients do with this
1. Hit `/api/taxii2/` to learn server identity + API root URLs
2. Hit each API root (`/api/taxii2/api/`) to discover available collections
3. Poll each collection's `/objects/` endpoint to fetch STIX bundles
## Integration walkthroughs
- **Microsoft Sentinel**: Data connectors → Threat Intelligence - TAXII → add server, paste discovery URL + API key
- **Splunk ES**: TA-TAXII2 add-on → input → server URL + Bearer token
- **OpenCTI**: TAXII 2.1 Connector → discovery URL + key
- **MISP**: Sync server type "TAXII 2.1" → discovery URL + key
# Authenticate with the SOC Defenders API
Source: https://docs.socdefenders.ai/authentication
Generate SOC Defenders API keys in Settings, pass them via Authorization: Bearer or X-API-Key headers, and handle 401 authentication error responses.
SOC Defenders uses API key authentication for all REST API requests. Every request you make must include a valid API key — requests without a key, or with an invalid or expired key, are rejected before reaching any endpoint. There are no session cookies or OAuth flows; the API key is the only credential you need.
## Getting your API key
Sign in at [socdefenders.ai](https://socdefenders.ai), then navigate to **Settings → API Keys**. Click **Create key**, give it a name, and copy the key value immediately — it is only shown once.
You can also reach the API Keys section from the [export page](https://socdefenders.ai/export#keys).
| Tier | API keys allowed |
| ---- | ---------------- |
| Free | Up to 3 |
| Pro | Up to 50 |
If you need to revoke a key, return to **Settings → API Keys** and delete it. The key stops working immediately.
## Passing your key
The SOC Defenders API accepts your key in two request headers. Use whichever fits your tooling or integration.
**Option 1: `Authorization` header with Bearer scheme**
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs?type=ipv4&limit=100"
```
**Option 2: `X-API-Key` header**
```bash theme={null}
curl -H "X-API-Key: sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs?type=ipv4&limit=100"
```
Both headers are equivalent. The `Authorization: Bearer` form is the standard HTTP convention and is the recommended default. Use `X-API-Key` if your infrastructure strips or rewrites the `Authorization` header.
## API key security
Keep your API key secret. Do not commit it to source control, paste it into chat tools, or include it in client-side code or public repositories. If a key is exposed, rotate it immediately by deleting it in **Settings → API Keys** and creating a new one.
Treat your API key like a password. Recommended practices:
* Store keys in environment variables or a secrets manager, not in code.
* Use separate keys for different environments (development, staging, production).
* Rotate keys periodically and immediately after any suspected exposure.
* Grant keys only the access level your integration actually needs — use Free-tier keys for testing rather than production Pro keys.
If you believe a key has been compromised, contact [security@socdefenders.ai](mailto:security@socdefenders.ai) in addition to rotating the key.
## Authentication errors
When a request fails authentication, the API returns a `401 Unauthorized` response with a JSON error body. For example, a request with a missing key returns:
```json theme={null}
{
"error": {
"code": "missing_api_key",
"message": "API key is required. Include it in the Authorization header as \"Bearer sk_live_...\" or in the X-API-Key header.",
"request_id": "req_..."
}
}
```
Use the `code` field to identify the problem programmatically. The `request_id` is useful when contacting support.
| Error code | Cause | Fix |
| ----------------- | ----------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| `missing_api_key` | No API key was included in the request. | Add the `Authorization: Bearer sk_live_...` or `X-API-Key` header. |
| `invalid_api_key` | The key was provided but does not match any active key on your account. | Check for typos or extra whitespace. Verify the key exists in **Settings → API Keys**. |
| `expired_api_key` | The key existed but has been deleted or has expired. | Create a new key in **Settings → API Keys** and update your integration. |
# Stream IOCs via CEF and Syslog to your log pipeline
Source: https://docs.socdefenders.ai/formats/cef-syslog
Use the SOC Defenders CEF endpoint to stream threat indicators in Common Event Format directly into your SIEM's log ingestion pipeline. Requires Pro.
The SOC Defenders CEF endpoint returns your filtered IOCs as Common Event Format log lines — one line per indicator. You can pipe the output directly into your syslog daemon or log collector, making it straightforward to ingest threat intelligence into ArcSight, QRadar, Splunk, or any other SIEM with a syslog input.
CEF/Syslog export requires a Pro subscription. Upgrade at [socdefenders.ai](https://socdefenders.ai).
## Endpoint
**`GET /api/v1/iocs/cef`**
The response body is plain text — one CEF log line per IOC, with no JSON envelope. This makes it suitable for direct piping into standard Unix log utilities.
## Authentication
Pass your API key as a Bearer token in the `Authorization` header.
## Query parameters
| Parameter | Type | Description |
| ------------ | ------ | -------------------------------------------------------------------------------------------- |
| `type` | string | Filter by IOC type: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `email` |
| `since` | string | ISO 8601 timestamp — return only IOCs added after this date |
| `confidence` | string | `low`, `medium`, or `high` |
| `industry` | string | CISA Critical Infrastructure sector slug |
## Example request
Fetch high-confidence IPv4 indicators and pipe them directly into your local syslog:
```bash theme={null}
curl -s -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs/cef?type=ipv4&confidence=high" \
| logger -p security.warning -t SOCDefenders
```
To write to a file instead:
```bash theme={null}
curl -s -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs/cef?since=2026-05-16T00:00:00Z" \
>> /var/log/soc-defenders-iocs.cef
```
## CEF field mapping
Each response line follows the CEF standard format:
```
CEF:Version|Device Vendor|Device Product|Device Version|Signature ID|Name|Severity|Extension
```
A sample line for a malicious IPv4 indicator looks like this:
```
CEF:0|SOC Defenders|Threat Intelligence|1.0|ipv4|Malicious IPv4 Indicator|7|src=203.0.113.42 cs1=high cs1Label=confidence cs2=CISA Alerts cs2Label=source rt=1747440000000
```
| CEF field | Value | Description |
| ------------------ | --------------------- | ----------------------------------------------------------- |
| `Version` | `0` | CEF format version |
| `Device Vendor` | `SOC Defenders` | Producer name |
| `Device Product` | `Threat Intelligence` | Product identifier |
| `Signature ID` | IOC type | e.g. `ipv4`, `domain`, `sha256` |
| `Name` | Human-readable label | Describes the indicator |
| `Severity` | `1`–`10` | Mapped from confidence: `low` → 3, `medium` → 6, `high` → 9 |
| `src` | IOC value | The raw indicator (IP, domain, hash, etc.) |
| `cs1` / `cs1Label` | Confidence string | `low`, `medium`, or `high` |
| `cs2` / `cs2Label` | Source feed name | e.g. `CISA Alerts` |
| `rt` | Unix timestamp (ms) | Time the IOC was ingested |
# Export SOC Defenders IOCs as a MISP event
Source: https://docs.socdefenders.ai/formats/misp
Download current IOCs as a MISP-compatible JSON event for import into your Malware Information Sharing Platform instance. Requires Pro.
The SOC Defenders MISP endpoint returns your filtered IOCs packaged as a MISP JSON event. You can import this file directly into any MISP instance using the standard file or URL import flow — no manual attribute creation required.
MISP export requires a Pro subscription. Upgrade at [socdefenders.ai](https://socdefenders.ai).
## Endpoint
**`GET /api/v1/iocs/misp`**
The response is a MISP-compatible JSON event containing one attribute per IOC.
## Authentication
Pass your API key as a Bearer token in the `Authorization` header.
## Query parameters
| Parameter | Type | Description |
| ------------ | ------ | -------------------------------------------------------------------------------------------- |
| `type` | string | Filter by IOC type: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `email` |
| `since` | string | ISO 8601 timestamp — return only IOCs added after this date |
| `confidence` | string | `low`, `medium`, or `high` |
| `industry` | string | CISA Critical Infrastructure sector slug |
## Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs/misp?type=domain&confidence=high" \
-o soc-defenders-iocs.json
```
## Importing into MISP
Run the curl command above to save the MISP JSON event to a local file, or copy the endpoint URL for direct URL import.
Navigate to **Sync Actions → Import from file** (or **Import from URL** if you want MISP to fetch directly).
Upload the downloaded JSON file, or paste the full endpoint URL including your `Authorization` header if your MISP version supports authenticated URL imports.
MISP previews the event attributes before committing. Review the attribute count and types, then click **Publish** to add the event to your instance.
Use the `since` parameter to pull only new IOCs since your last import. Store the timestamp of each successful import and pass it as `since` in your next request to avoid duplicate attributes.
# Export formats for threat intelligence data
Source: https://docs.socdefenders.ai/formats/overview
SOC Defenders supports JSON, CSV, STIX 2.1, TAXII 2.1, MISP, CEF/Syslog, OpenIOC, and Sigma rules. Free and Pro format availability explained.
SOC Defenders lets you consume threat intelligence in the format that fits your existing stack. Free tier accounts can pull IOCs and articles as JSON or CSV, look up individual indicators, and read aggregated news. Pro accounts unlock industry-standard formats for automated SIEM ingestion, platform integrations, and deployable detection rules — including STIX 2.1, TAXII 2.1, MISP, CEF/Syslog, OpenIOC, and Sigma.
## All supported formats
| Format | Tier | Endpoint | Use case |
| --------------- | ---- | ----------------------------- | ------------------------------------------- |
| JSON | Free | `GET /api/v1/iocs` | Flexible REST consumption, custom pipelines |
| CSV | Free | `GET /api/v1/iocs?format=csv` | Spreadsheet analysis, bulk imports |
| IOC Lookup | Free | `GET /api/v1/lookup` | Single-value enrichment |
| News Articles | Free | `GET /api/v1/articles` | Article aggregation, delta polling |
| STIX 2.1 | Pro | `GET /api/v1/iocs/stix` | Standard threat intel bundles |
| TAXII 2.1 | Pro | `GET /api/taxii2/` | Automated SIEM feed polling |
| CEF/Syslog | Pro | `GET /api/v1/iocs/cef` | Log pipeline / SIEM ingestion |
| MISP | Pro | `GET /api/v1/iocs/misp` | MISP platform import |
| OpenIOC | Pro | `GET /api/v1/iocs/openioc` | Mandiant OpenIOC XML |
| Sigma | Pro | `GET /api/v1/iocs/sigma` | Deployable detection rules |
| Articles NDJSON | Pro | `GET /api/v1/articles` (bulk) | Bulk news export with cursor pagination |
## Pro export formats
The formats below are available on the Pro tier and are designed for automated ingestion and platform integration. Each has a dedicated page with endpoint details, request examples, and filter parameters.
Pull IOC bundles in the OASIS STIX 2.1 standard or configure automated TAXII 2.1 feed polling directly into your SIEM.
Download current IOCs as a MISP-compatible JSON event for import into your Malware Information Sharing Platform instance.
Stream IOCs as Common Event Format log lines directly into syslog-based SIEM pipelines such as ArcSight and QRadar.
Generate deployable YAML detection rules for each IOC, ready to convert and import into any Sigma-compatible SIEM.
# Generate Sigma detection rules from IOCs
Source: https://docs.socdefenders.ai/formats/sigma
The SOC Defenders Sigma endpoint returns deployable YAML detection rules for each IOC, ready to import into any SIEM that supports Sigma. Requires Pro.
The SOC Defenders Sigma endpoint converts your filtered IOCs into deployable Sigma detection rules. Each IOC becomes its own YAML rule document, separated by `---` in the multi-document response. You can pipe the output directly into `sigmac` or `pySigma` to compile rules for your target SIEM without writing any detection logic manually.
Sigma export requires a Pro subscription. Upgrade at [socdefenders.ai](https://socdefenders.ai).
## Endpoint
**`GET /api/v1/iocs/sigma`**
The response is a multi-document YAML file. Each document is a valid Sigma rule for one IOC, delimited by `---`.
## Authentication
Pass your API key as a Bearer token in the `Authorization` header.
## Query parameters
| Parameter | Type | Description |
| ------------ | ------ | -------------------------------------------------------------------------------------------- |
| `type` | string | Filter by IOC type: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `email` |
| `since` | string | ISO 8601 timestamp — return only IOCs added after this date |
| `confidence` | string | `low`, `medium`, or `high` |
| `industry` | string | CISA Critical Infrastructure sector slug |
## Example request
```bash theme={null}
curl -s -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs/sigma?type=ipv4&confidence=high" \
-o soc-defenders-rules.yml
```
## Sample Sigma rule output
The following shows a single rule document from the multi-document response:
```yaml theme={null}
title: SOC Defenders - Malicious IPv4 Indicator
id: f1e2d3c4-b5a6-7890-abcd-ef0987654321
status: experimental
description: Detects network activity involving a malicious IPv4 address identified by SOC Defenders threat intelligence.
references:
- https://socdefenders.ai
author: SOC Defenders
date: 2026-05-17
tags:
- attack.command-and-control
logsource:
category: network_connection
product: windows
detection:
selection:
DestinationIp: '203.0.113.42'
condition: selection
fields:
- SourceIp
- DestinationIp
- DestinationPort
falsepositives:
- Unknown
level: high
```
Each rule includes a unique `id`, references back to SOC Defenders, and maps to relevant MITRE ATT\&CK tags where available.
## Deploying Sigma rules to your SIEM
Sigma rules are backend-agnostic YAML. Use `sigmac` (legacy) or `pySigma` (recommended) to compile them into queries your SIEM understands.
Run the curl example above to save all rules to a `.yml` file. Use the `type` and `confidence` filters to limit the output to IOCs relevant to your environment.
Install the pySigma core library and the backend plugin for your SIEM:
```bash theme={null}
pip install pysigma
# Example: Splunk backend
pip install pysigma-backend-splunk
```
Convert the multi-document YAML to your target query language. The example below targets Splunk:
```bash theme={null}
sigma convert -t splunk soc-defenders-rules.yml
```
Replace `-t splunk` with `-t qradar`, `-t elastic`, `-t sentinel`, or any other supported backend.
Copy the compiled queries into your SIEM's detection or correlation rule editor. For automated pipelines, run the `sigma convert` step as part of your scheduled IOC refresh script.
Schedule a cron job to fetch fresh rules with `since` set to your last run timestamp, then recompile and push updated rules to your SIEM. This keeps your detection logic synchronized with the latest SOC Defenders IOC feed.
# Export threat intel in STIX 2.1 and TAXII 2.1
Source: https://docs.socdefenders.ai/formats/stix-taxii
Pull IOCs as STIX 2.1 indicator bundles or configure automated TAXII 2.1 feed polling for your SIEM. Both formats require a Pro subscription.
SOC Defenders supports two complementary standards for structured threat intelligence sharing. The STIX 2.1 endpoint returns a point-in-time bundle of indicators you can download on demand. The TAXII 2.1 server exposes the same data as a live feed your SIEM can poll automatically — no custom scripts required.
Both STIX 2.1 and TAXII 2.1 require a Pro subscription. Upgrade at [socdefenders.ai](https://socdefenders.ai).
## STIX 2.1 export
The STIX endpoint returns a valid STIX 2.1 bundle containing `indicator` objects for each IOC and a single `identity` object representing SOC Defenders as the producer.
**Endpoint:** `GET /api/v1/iocs/stix`
### Authentication
Pass your API key as a Bearer token in the `Authorization` header.
### Query parameters
The STIX endpoint accepts the same filter parameters as `GET /api/v1/iocs`:
| Parameter | Type | Description |
| ------------ | ------ | -------------------------------------------------------------------------------------------- |
| `type` | string | Filter by IOC type: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `email` |
| `since` | string | ISO 8601 timestamp — return only IOCs added after this date |
| `industry` | string | CISA Critical Infrastructure sector slug |
| `confidence` | string | `low`, `medium`, or `high` |
### Example request
```bash theme={null}
curl -H "Authorization: Bearer sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/v1/iocs/stix?type=ipv4&confidence=high"
```
### Response structure
The response is a STIX 2.1 bundle. Each IOC appears as an `indicator` object inside the `objects` array.
```json theme={null}
{
"type": "bundle",
"spec_version": "2.1",
"id": "bundle--a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"objects": [
{
"type": "identity",
"spec_version": "2.1",
"id": "identity--socdefenders",
"name": "SOC Defenders",
"identity_class": "organization"
},
{
"type": "indicator",
"spec_version": "2.1",
"id": "indicator--f1e2d3c4-b5a6-7890-abcd-ef0987654321",
"created": "2026-05-17T00:00:00.000Z",
"modified": "2026-05-17T00:00:00.000Z",
"name": "Malicious IPv4: 203.0.113.42",
"pattern": "[ipv4-addr:value = '203.0.113.42']",
"pattern_type": "stix",
"valid_from": "2026-05-17T00:00:00.000Z",
"indicator_types": ["malicious-activity"],
"confidence": 85
}
]
}
```
***
## TAXII 2.1 server
The SOC Defenders TAXII 2.1 server lets your SIEM poll for new threat intelligence automatically using the standard TAXII protocol. Configure it once and your SIEM fetches updates on its own schedule.
**Discovery endpoint:** `GET /api/taxii2/`
**API root:** `https://www.socdefenders.ai/api/taxii2/api/`
### Authentication
Pass your API key as the password in HTTP Basic Auth, or use an `Authorization: Bearer` header — both are accepted.
```bash theme={null}
curl -u "your_email@example.com:sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/taxii2/"
```
### TAXII endpoints
| Endpoint | Description |
| ----------------------------------------------- | ------------------------------------------------------------------------ |
| `GET /api/taxii2/` | Server discovery — returns API roots and server metadata |
| `GET /api/taxii2/api/collections/` | List available collections (all IOCs, IPs only, hashes only, CVEs, etc.) |
| `GET /api/taxii2/api/collections/{id}/objects/` | Paginated STIX objects from a specific collection |
### Discovery response
Calling the discovery endpoint returns the server title, description, and available API roots:
```json theme={null}
{
"title": "SOC Defenders TAXII 2.1 Server",
"description": "Aggregated threat intelligence from 30+ cybersecurity sources",
"contact": "support@socdefenders.ai",
"api_roots": [
"https://www.socdefenders.ai/api/taxii2/api/"
]
}
```
### Fetching objects from a collection
Once you have a collection ID from the `/collections/` endpoint, retrieve its STIX objects:
```bash theme={null}
curl -u "your_email@example.com:sk_live_YOUR_KEY" \
"https://socdefenders.ai/api/taxii2/api/collections/all-iocs/objects/?limit=100"
```
The response returns a standard TAXII envelope containing STIX objects, with `next` cursor values for pagination.
# Send SOC Defenders threat data to Elastic Security
Source: https://docs.socdefenders.ai/integrations/elastic
Configure Elastic Security to ingest IOCs from SOC Defenders using the REST API or TAXII feed. Includes filebeat configuration and EQL detection examples.
Elastic Security stores threat indicators in the `threat.indicator` fields of the Elastic Common Schema (ECS), making them available for correlation rules, timeline investigations, and indicator match rules. You can populate these fields by polling the SOC Defenders REST API with a Python script or custom integration, or — on Pro — by configuring the Threat Intelligence TAXII integration in Elastic Agent to handle polling automatically.
## Option 1: REST API with custom ingest
Use a Python script to poll `GET /api/v1/iocs` on a schedule, map the response fields to ECS, and index the documents into Elasticsearch.
### Poll the API and index to Elasticsearch
The following script fetches IPv4 indicators and indexes them into an Elasticsearch index named `logs-ti.socdefenders-default`. Adjust the `IOC_TYPE` and `INDEX` variables to suit your environment.
```python poll_and_index.py theme={null}
import requests
from datetime import datetime, timezone
from elasticsearch import Elasticsearch
SOC_API_KEY = "YOUR_API_KEY"
SOC_BASE_URL = "https://socdefenders.ai/api/v1/iocs"
ES_HOST = "https://your-elasticsearch-host:9200"
ES_API_KEY = "YOUR_ES_API_KEY"
INDEX = "logs-ti.socdefenders-default"
IOC_TYPE = "ipv4"
es = Elasticsearch(ES_HOST, api_key=ES_API_KEY)
def fetch_iocs(ioc_type: str, limit: int = 1000) -> list:
resp = requests.get(
SOC_BASE_URL,
headers={"Authorization": f"Bearer {SOC_API_KEY}"},
params={"type": ioc_type, "limit": limit},
timeout=30,
)
resp.raise_for_status()
return resp.json().get("data", [])
def to_ecs(ioc: dict) -> dict:
return {
"@timestamp": datetime.now(timezone.utc).isoformat(),
"event": {"kind": "enrichment", "category": ["threat"], "type": ["indicator"]},
"threat": {
"indicator": {
"type": "ipv4-addr",
"ip": ioc.get("value"),
"confidence": ioc.get("confidence"),
"provider": ioc.get("source", {}).get("feed_name"),
}
},
}
iocs = fetch_iocs(IOC_TYPE)
for ioc in iocs:
es.index(index=INDEX, document=to_ecs(ioc))
print(f"Indexed {len(iocs)} indicators.")
```
Run this script on a schedule using cron or a task scheduler. For Free tier accounts, a 15-minute interval keeps you within the rate limit. Pro accounts can reduce the interval to 1 minute.
### ECS field mapping
| SOC Defenders field | ECS field |
| ------------------- | ----------------------------------- |
| `value` (IP) | `threat.indicator.ip` |
| `value` (domain) | `threat.indicator.url.domain` |
| `value` (hash) | `threat.indicator.file.hash.sha256` |
| `confidence` | `threat.indicator.confidence` |
| `source.feed_name` | `threat.indicator.provider` |
| `type` | `threat.indicator.type` |
## Option 2: TAXII via Elastic Agent (Pro)
Elastic Agent includes a **Threat Intelligence** integration that supports TAXII 2.1 feeds. Once configured, Elastic Agent polls the SOC Defenders TAXII server on a schedule and indexes STIX 2.1 objects directly into ECS-mapped fields — no custom code required.
The TAXII integration requires a SOC Defenders Pro subscription.
In Kibana, go to **Fleet → Integrations** and search for **Threat Intelligence**. Select the integration and click **Add Threat Intelligence**.
In the integration settings, choose **TAXII** as the source type and enter the following:
| Field | Value |
| ------------- | --------------------------------------------- |
| TAXII server | `https://www.socdefenders.ai/api/taxii2/api/` |
| Collection ID | `all` (or `ips`, `hashes`, `cves`) |
| Username | `apikey` |
| Password | Your SOC Defenders API key |
| Poll interval | `1h` |
Assign the integration to an Elastic Agent policy and deploy. Elastic Agent will begin polling and indexing indicators automatically.
In Kibana Discover, filter on `event.category: threat` and `event.type: indicator` to confirm indicators are arriving.
## Detection with EQL
Once indicators are indexed, use indicator match rules or the following EQL query to hunt for network connections to known-malicious IPs in your environment.
### Correlate network events with ingested IP indicators
```eql theme={null}
sequence by host.id
[network where event.category == "network" and network.direction == "egress"]
[any where event.dataset == "ti.socdefenders" and threat.indicator.type == "ipv4-addr"]
until [network where event.category == "network" and network.direction == "egress"
and threat.indicator.ip == destination.ip]
```
For a simpler ad-hoc search using ES|QL:
```esql theme={null}
FROM logs-ti.socdefenders-default
| WHERE threat.indicator.type == "ipv4-addr"
| STATS count = COUNT(*) BY threat.indicator.ip, threat.indicator.confidence
| SORT count DESC
| LIMIT 50
```
# Connect SOC Defenders to Microsoft Sentinel
Source: https://docs.socdefenders.ai/integrations/microsoft-sentinel
Import SOC Defenders threat indicators into Microsoft Sentinel via TAXII 2.1 or the REST API. Includes Defender TAXII connector configuration steps.
Microsoft Sentinel can consume SOC Defenders threat indicators through its native TAXII Threat Intelligence connector — the lowest-effort path for Pro subscribers — or via an Azure Logic App that polls the REST API and pushes indicators through the Microsoft Security Graph. Both methods populate the `ThreatIntelligenceIndicator` table, making indicators immediately available for analytics rules, hunting queries, and workbooks.
## Option 1: TAXII Threat Intelligence connector (Pro)
The TAXII connector is built into Sentinel and requires no custom code. It polls the SOC Defenders TAXII server on a schedule and maps STIX 2.1 indicator objects directly into the `ThreatIntelligenceIndicator` table.
TAXII 2.1 integration requires a SOC Defenders Pro subscription.
### Configure the connector
In the Azure portal, navigate to your Sentinel workspace. In the left menu, select **Data connectors**.
Search for **Threat Intelligence – TAXII** and open the connector page. Click **Open connector page**.
Under **Configuration**, click **Add new** and enter the following values:
| Field | Value |
| ------------------------- | --------------------------------------------------------------------------- |
| Friendly name | SOC Defenders |
| TAXII server API Root URL | `https://www.socdefenders.ai/api/taxii2/api/` |
| Collection ID | See available collections below |
| Username | Leave blank, or enter `apikey` |
| Password | Your SOC Defenders API key |
| Import indicators | `At most one month old` (or choose a range that fits your retention policy) |
| Poll interval | 1 hour |
Available collection IDs on the SOC Defenders TAXII server:
| Collection | ID |
| ----------- | -------- |
| All IOCs | `all` |
| IPs only | `ips` |
| Hashes only | `hashes` |
| CVEs | `cves` |
You can add multiple connector entries — one per collection — if you want to separate indicator types into different ingestion streams.
Click **Add**. Sentinel will begin polling within a few minutes. To confirm, run the following KQL query in the Logs blade:
```kql theme={null}
ThreatIntelligenceIndicator
| where SourceSystem == "SOC Defenders"
| take 10
```
## Option 2: REST API with Logic Apps
If you are on the Free tier or want more control over field mapping and filtering, use an Azure Logic App to poll `GET /api/v1/iocs` and push indicators to Sentinel via the Microsoft Security Graph `tiIndicators` API.
In Azure Active Directory, register a new application. Grant it the `ThreatIndicators.ReadWrite.OwnedBy` permission in Microsoft Graph. Note the **client ID**, **tenant ID**, and **client secret**.
Create a new Logic App with a **Recurrence** trigger. Set the interval to 15 minutes (Free tier) or 1 minute (Pro).
Add an **HTTP** action with:
* **Method**: `GET`
* **URI**: `https://socdefenders.ai/api/v1/iocs?type=ipv4&limit=100`
* **Headers**: `Authorization: Bearer YOUR_API_KEY`
Add a **Parse JSON** action to extract the `data` array, then loop through each IOC and call the Microsoft Graph `tiIndicators` endpoint to create or update the indicator in Sentinel.
```
POST https://graph.microsoft.com/beta/security/tiIndicators
```
## Hunting with KQL
Once indicators are in the `ThreatIntelligenceIndicator` table, use these KQL examples to hunt for matches.
### Correlate network connections with IP indicators
```kql theme={null}
let iocs = ThreatIntelligenceIndicator
| where isnotnull(NetworkIP)
| project NetworkIP, ConfidenceScore, Description, ExpirationDateTime;
NetworkConnection
| join kind=inner iocs on $left.DestinationIP == $right.NetworkIP
| where ExpirationDateTime > now()
| project TimeGenerated, SourceIP, DestinationIP, ConfidenceScore, Description
| sort by TimeGenerated desc
```
### Hunt for DNS queries matching domain indicators
```kql theme={null}
let domainIocs = ThreatIntelligenceIndicator
| where isnotnull(DomainName)
| project DomainName, ConfidenceScore, ThreatType, ExpirationDateTime;
DnsEvents
| join kind=inner domainIocs on $left.Name == $right.DomainName
| where ExpirationDateTime > now()
| project TimeGenerated, ClientIP, Name, ConfidenceScore, ThreatType
| sort by TimeGenerated desc
```
# Integrating SOC Defenders with your SIEM
Source: https://docs.socdefenders.ai/integrations/siem-overview
Connect SOC Defenders threat intelligence to Splunk, Microsoft Sentinel, IBM QRadar, Elastic Security, or Google Chronicle using REST, TAXII 2.1, or CEF/Syslog.
SOC Defenders aggregates threat indicators from 30+ cybersecurity sources and makes them available through multiple integration methods so you can get IOCs into your SIEM without building a custom pipeline from scratch. Whether you prefer polling a REST API on a schedule, using the native TAXII 2.1 protocol your SIEM already understands, or streaming events over a syslog pipeline, there is an approach that fits your existing stack.
## Integration approaches
SOC Defenders supports three primary methods for delivering threat intelligence to your SIEM.
### REST API polling (JSON or CSV)
Available on the Free and Pro tiers, the REST API is the most flexible option. You poll `GET /api/v1/iocs` on a schedule — every 15 minutes is recommended for Free accounts, while Pro accounts can poll continuously. The API returns paginated JSON or CSV that you can parse and forward to your SIEM using a scripted input, Azure Logic App, or any HTTP-capable automation tool.
```bash theme={null}
curl -H "Authorization: Bearer YOUR_API_KEY" \
"https://socdefenders.ai/api/v1/iocs?type=ipv4&limit=100"
```
Use REST when you need custom field mapping, want to filter IOCs before ingestion, or are building a bespoke pipeline.
### TAXII 2.1 (Pro)
TAXII 2.1 is the industry-standard protocol for threat intelligence feed distribution. SOC Defenders exposes a TAXII server at `https://www.socdefenders.ai/api/taxii2/` that your SIEM's native threat intelligence connector can poll automatically. Collections are organized by IOC type (all IOCs, IPs only, hashes only, CVEs), and indicators are delivered as STIX 2.1 objects.
Use TAXII when your SIEM has a built-in threat intelligence module — Splunk Enterprise Security and Microsoft Sentinel both have native TAXII connectors — and you want zero-maintenance feed ingestion.
### CEF/Syslog (Pro)
The `GET /api/v1/iocs/cef` endpoint returns IOCs in Common Event Format, ready for ingestion through any syslog-based log pipeline. Use CEF/Syslog when your organization already routes security events through a syslog forwarder and wants to treat threat indicators as another log source.
## Supported SIEMs
| SIEM | REST API | TAXII 2.1 | CEF/Syslog |
| ------------------ | -------- | --------- | ---------- |
| Splunk | Yes | Yes (Pro) | Yes (Pro) |
| Microsoft Sentinel | Yes | Yes (Pro) | Yes (Pro) |
| IBM QRadar | Yes | Yes (Pro) | Yes (Pro) |
| Elastic Security | Yes | Yes (Pro) | Yes (Pro) |
| Google Chronicle | Yes | Yes (Pro) | Yes (Pro) |
## Choosing an approach
* **REST API** — best for custom pipelines, scripted inputs, or when you need to filter or transform indicators before ingestion.
* **TAXII 2.1** — best for SIEMs with native threat intelligence connectors; requires Pro and provides the lowest-maintenance integration.
* **CEF/Syslog** — best for organizations routing all security data through a centralized syslog forwarder.
## SIEM integration guides
Pull IOCs via REST scripted input or TAXII 2.1 in Splunk Enterprise Security. Includes SPL hunting queries.
Configure the TAXII Threat Intelligence connector or poll via Logic Apps. Includes KQL hunting queries.
Ingest IOCs through the REST API or Elastic Agent TAXII integration. Includes EQL detection examples.
Reference for TAXII collections, STIX object structure, and authentication.
# Ingest SOC Defenders IOCs into Splunk
Source: https://docs.socdefenders.ai/integrations/splunk
Configure Splunk to pull threat indicators from SOC Defenders via the REST API or TAXII 2.1 feed. Includes example SPL hunting queries.
You can bring SOC Defenders threat indicators into Splunk either by polling the REST API with a scripted input or HTTP Event Collector, or by connecting Splunk Enterprise Security's Threat Intelligence Management module to the SOC Defenders TAXII 2.1 feed. The REST approach works on any Splunk deployment and is available on the Free tier; TAXII requires Splunk Enterprise Security and a Pro subscription.
## Option 1: REST API polling
Use a scripted input or the HTTP Event Collector (HEC) to poll `GET /api/v1/iocs` on a schedule and forward the results to Splunk.
### Set up the scripted input
In the SOC Defenders dashboard, open the **API Keys** tab and create a new key. Copy the key value — you will not be able to view it again.
Save the following script on your Splunk heavy forwarder or search head. Replace `YOUR_API_KEY` and `YOUR_HEC_TOKEN` with your actual values.
```bash poll-iocs.sh theme={null}
#!/bin/bash
curl -s \
-H "Authorization: Bearer YOUR_API_KEY" \
"https://socdefenders.ai/api/v1/iocs?type=ipv4&limit=100" | \
curl -s -X POST \
-H "Authorization: Splunk YOUR_HEC_TOKEN" \
-H "Content-Type: application/json" \
--data-binary @- \
"https://your-splunk-host:8088/services/collector/raw"
```
In Splunk Web, go to **Settings → Data inputs → Scripts** and add the script. Set the interval to `900` seconds (15 minutes) for Free tier accounts. Pro accounts can reduce the interval to 60 seconds or lower.
Free tier accounts are limited to 100 IOCs per request and 1,000 requests per day. If you need higher throughput or longer lookback periods (up to 365 days), upgrade to Pro.
### Recommended poll intervals
| Tier | Recommended interval |
| ---- | ------------------------------ |
| Free | Every 15 minutes |
| Pro | Every 1 minute or continuously |
## Option 2: TAXII 2.1 (Pro)
Splunk Enterprise Security includes a Threat Intelligence Management module with a built-in TAXII client. You can point it directly at the SOC Defenders TAXII server for automatic, scheduled feed polling.
TAXII 2.1 integration requires a SOC Defenders Pro subscription and Splunk Enterprise Security.
### Configure the TAXII feed
In Splunk Enterprise Security, go to **Security Intelligence → Threat Intelligence Management → Threat Intelligence Sources**.
Click **New Source** and select **TAXII Feed**. Fill in the following fields:
| Field | Value |
| ---------------- | ----------------------------------------- |
| Name | SOC Defenders |
| TAXII server URL | `https://www.socdefenders.ai/api/taxii2/` |
| Username | `apikey` |
| Password | Your SOC Defenders API key |
| Poll interval | 60 minutes (adjust to your needs) |
After connecting, choose from the available collections:
* **All IOCs** — every indicator type
* **IPs only** — IPv4 and IPv6 addresses
* **Hashes only** — MD5, SHA1, SHA256
* **CVEs** — vulnerability identifiers
Save the source. Splunk ES will begin polling immediately. You can verify ingestion under **Security Intelligence → Threat Intelligence Sources** — look for a green status indicator and a non-zero indicator count.
## Hunting with SPL
Once IOCs are in Splunk, use the following SPL examples to hunt for matches in your environment.
### Match network traffic against ingested IP indicators
```spl theme={null}
index=network sourcetype=firewall
| lookup threat_intel_by_ip src_ip AS dest_ip OUTPUT threat_key, threat_collection
| where isnotnull(threat_key)
| table _time, src_ip, dest_ip, action, threat_key, threat_collection
```
### Match DNS queries against ingested domain indicators
```spl theme={null}
index=dns sourcetype=dns_logs
| lookup threat_intel_by_domain query AS domain OUTPUT threat_key, confidence
| where isnotnull(threat_key)
| table _time, src_ip, domain, threat_key, confidence
| sort -_time
```
# SOC Defenders: Threat Intelligence Platform Overview
Source: https://docs.socdefenders.ai/introduction
SOC Defenders aggregates cybersecurity news and IOCs from 30+ sources. Learn what the platform offers and how to get started as a customer.
SOC Defenders is a threat intelligence platform built for SOC analysts, security engineers, and security operations teams. It continuously aggregates cybersecurity news, indicators of compromise (IOCs), and CVE data from more than 30 sources, then delivers that intelligence through a filterable web feed, a REST API, and a TAXII 2.1 server — so you can enrich your investigations, feed your SIEM, and stay ahead of active threats without stitching together dozens of individual feeds yourself.
Explore the threat news feed, IOC lookup, CVE database, and industry threat view.
Full reference for every endpoint — IOCs, articles, STIX, TAXII, and more.
Connect SOC Defenders to Splunk, Microsoft Sentinel, Elastic, and more.
STIX 2.1, TAXII 2.1, MISP, CEF/Syslog, OpenIOC, Sigma rules, JSON, and CSV.
## What the platform provides
**Threat news feed** — A continuously updated feed of cybersecurity articles aggregated from 30+ sources. You can filter by category (attacks and breaches, malware, vulnerabilities, and more), severity, industry sector, MITRE ATT\&CK technique, threat actor, and technology. Articles are enriched with extracted IOCs, CVEs, and MITRE technique mappings so you can pivot from a news item directly into an investigation.
**IOC feed** — A structured feed of indicators of compromise including IPv4, IPv6, domains, URLs, MD5/SHA1/SHA256 file hashes, CVEs, MITRE ATT\&CK techniques, and email addresses. Indicators include confidence ratings and source attribution. Use the IOC lookup endpoint to enrich a single indicator with AI risk scoring and auto-generated Splunk and KQL hunting queries.
**CVE database** — Search and browse CVEs enriched with CISA Known Exploited Vulnerabilities (KEV) status and EPSS exploit probability scores, so you can prioritize patching by actual exploitation risk rather than raw CVSS score alone.
**Industry threat view** — IOCs and threat articles segmented by CISA Critical Infrastructure sectors, letting you filter intelligence to the industries most relevant to your organization.
**Community** — Access community-contributed threat intelligence and stay connected with other security practitioners using the platform.
## The API
SOC Defenders exposes a REST API and a TAXII 2.1 server for programmatic access to all threat intelligence. Use the REST API to pull IOC lists, search for specific indicators, retrieve enriched news articles, and export data in multiple formats. Use the TAXII 2.1 server to poll collections automatically from any TAXII-compatible SIEM or threat intelligence platform.
All API access requires an API key passed in the `Authorization` header or `X-API-Key` header. See [Authentication](/authentication) to get started, or jump to the [API reference](/api-reference/overview) for full endpoint documentation.
## Free vs Pro
SOC Defenders offers two tiers. The Free tier is available immediately with no credit card required and covers most individual and small-team use cases. The Pro tier is designed for security teams and organizations that need higher throughput, longer data lookback, and SIEM-native export formats.
| Feature | Free | Pro |
| -------------------- | ------------------------- | -------------------------------- |
| Rate limit | 10 req/min, 1,000 req/day | 1,000 req/min, 1,000,000 req/day |
| Lookback period | 1 day | 1 year |
| Results per request | 100 | 10,000 |
| JSON / CSV export | Yes | Yes |
| STIX 2.1 / TAXII 2.1 | — | Yes |
| MISP / CEF / OpenIOC | — | Yes |
| Sigma rules | — | Yes |
| API keys | Up to 3 | Up to 50 |
| Support | Community | Priority email |
| Uptime SLA | — | 99.9% |
Pro is $299/month, or $2,990/year (\$249/month). Sign in at [socdefenders.ai](https://socdefenders.ai) to start a trial.
## Supported SIEM integrations
SOC Defenders works directly with the following platforms:
* **Splunk** — Ingest IOCs via REST API or TAXII 2.1 feed. Auto-generated Splunk hunting queries are available per indicator through the IOC lookup endpoint.
* **Microsoft Sentinel** — Connect via TAXII 2.1 or REST API. KQL hunting queries are generated per IOC in the lookup response.
* **IBM QRadar** — Ingest via TAXII 2.1 or CEF/Syslog stream (Pro).
* **Elastic Security** — Pull IOCs via REST API or TAXII 2.1 feed.
* **Google Chronicle** — Ingest STIX 2.1 bundles or connect via TAXII 2.1 (Pro).
See the [integrations guides](/integrations/siem-overview) for step-by-step setup instructions for each platform.
# SOC Defenders community: karma, voting, and contributions
Source: https://docs.socdefenders.ai/platform/community
Learn how to participate in the SOC Defenders security community — submit articles, upvote content, comment on threats, and build karma.
SOC Defenders is built around an active community of security professionals who surface, discuss, and validate threat intelligence together. By voting on articles, commenting on threats, and submitting new content, you help the community distinguish signal from noise — and build a reputation that reflects your contributions.
## Submitting articles
To share an article with the community, use the **Submit** page. Paste the URL of the article you want to share, select a category, and submit. Your submission enters the feed where other members can vote on it, comment, and save it.
The submissions page lists all community-submitted articles and supports the same category, severity, and IOC filters as the main news feed, so you can browse submissions by topic.
## Voting
Each article displays a vote count. Use the **upvote** button to signal that an article is relevant, accurate, or valuable to the community. Voting affects how articles rank in the **Hot** and **Top** feed views, surfacing the most useful content to more members.
You can also upvote and downvote **comments** within article discussion threads (subject to karma requirements — see below).
## Commenting
Open any article and scroll to the **Discussion** section to leave a comment. Comments let you add context, share related IOCs, flag inaccuracies, or discuss detection strategies with other practitioners. You must be signed in to comment.
## Saving articles
Click **Save** on any article to add it to your **Saved Articles** list. Your saved articles are available at any time from the **Saved** section of the platform, making it easy to build a personal reading list or reference collection of relevant threats.
## Karma
Karma is a measure of the quality of your contributions to the community. It is calculated solely from the votes other members cast on your comments — not on articles you submit.
| Action | Effect |
| ------------------------------------- | -------- |
| Another member upvotes your comment | +1 karma |
| Another member downvotes your comment | -1 karma |
Your karma level unlocks additional community capabilities:
| Karma threshold | Capability unlocked |
| --------------- | -------------------------------------------------- |
| 0+ | Upvote comments |
| 20+ | Flag content for review; vouch for content quality |
| 50+ | Downvote comments |
The fastest way to build karma is to leave specific, substantive comments — analysis of a technique, a detection note, or context that other analysts find useful. Generic comments attract fewer upvotes than comments that add something the article itself doesn't say.
## Leaderboard
The **Karma Leaderboard** ranks community members by total karma points, recognizing top contributors. The leaderboard is a useful way to find experienced analysts worth following and to gauge the depth of engagement within the community.
## Daily email newsletter
Subscribe to **Get Daily Threat Intel** to receive a curated digest of the day's most significant cybersecurity news delivered to your inbox every morning. Enter your email address in the newsletter signup at the bottom of the feed. You can unsubscribe at any time.
## Community guidelines
All participation on SOC Defenders is subject to the platform's acceptable use policy. Submissions, comments, and votes should contribute to accurate, useful threat intelligence — not spam, self-promotion, or misinformation.
# Searching the CVE database with CISA KEV and EPSS
Source: https://docs.socdefenders.ai/platform/cve-database
Browse and search the SOC Defenders CVE database, enriched with CISA Known Exploited Vulnerabilities status and EPSS exploit probability scores.
The SOC Defenders CVE database gives you a searchable view of vulnerabilities sourced from the National Vulnerability Database (NVD), enriched with two critical prioritization signals: CISA Known Exploited Vulnerabilities (KEV) status and EPSS exploit probability scores. Together these signals help you focus patching and detection effort on vulnerabilities that pose real, active risk — not just theoretical severity.
## What the database contains
Every CVE entry includes:
* CVE identifier and description from NVD
* CVSS base score and severity rating (Critical, High, Medium, Low)
* CISA KEV flag — whether the vulnerability is confirmed as actively exploited in the wild
* EPSS score — the probability that the vulnerability will be exploited in the next 30 days
* Published date
## Searching by CVE ID
Type a CVE identifier (e.g., `CVE-2024-12345`) into the **CVE Search** box at the top of the database page. The list filters to matching entries as you type.
## Severity filtering
Use the severity buttons to restrict the list to vulnerabilities in a given CVSS band:
| Severity | CVSS range |
| -------- | ---------- |
| Critical | 9.0–10.0 |
| High | 7.0–8.9 |
| Medium | 4.0–6.9 |
| Low | 0.1–3.9 |
You can select multiple severity levels simultaneously.
## CISA KEV filter
Enable **CISA KEV Only** to show only vulnerabilities that CISA has confirmed are being actively exploited in the wild. The KEV catalog is maintained by CISA and represents the highest-priority vulnerabilities for remediation — federal agencies are required to patch them within set deadlines, and the catalog is a reliable signal for any organization's patching queue.
## Sort options
Sort the database using any of three columns:
* **Published Date** — most recently disclosed CVEs first
* **CVSS Score** — highest severity first
* **EPSS Score** — highest exploitation probability first
Sorting by EPSS is particularly useful when you want to prioritize based on real-world exploitation likelihood rather than theoretical severity alone.
## Understanding EPSS
The Exploit Prediction Scoring System (EPSS) is a community-driven model that estimates the probability a given CVE will be exploited in the wild within the next 30 days. Scores range from 0.0 to 1.0 (0% to 100%). A high EPSS score means exploitation tooling exists or active exploitation has been observed, making the vulnerability a strong candidate for immediate attention regardless of its CVSS score.
## Understanding CISA KEV
The CISA Known Exploited Vulnerabilities catalog lists CVEs for which CISA has confirmed active exploitation. A KEV designation means threat actors are using the vulnerability right now, in real attacks, against real targets. When a CVE appears in the KEV catalog, treat it as requiring immediate remediation.
## API access
You can query CVE-related articles programmatically using the articles endpoint with a CVE tag filter:
```bash theme={null}
curl -H "Authorization: Bearer YOUR_API_KEY" \
"https://socdefenders.ai/api/v1/articles?tag=CVE-2024-12345"
```
For the full list of supported parameters, see the [API documentation](https://socdefenders.ai/docs/api).
# Viewing threat intelligence by industry sector
Source: https://docs.socdefenders.ai/platform/industry-threats
Filter SOC Defenders IOCs and threat articles by CISA Critical Infrastructure sector. Choose from 24-hour, 7-day, 30-day, or 90-day time windows.
The Industry Threats page organizes IOCs and threat reporting by the industry sectors they target, using the CISA Critical Infrastructure framework as its taxonomy. Instead of filtering a general feed, you get a focused view of the threat landscape relevant to your sector — which campaigns are active, which indicators are circulating, and how the picture has changed over a selected time window.
## Time period filters
Use the period selector to control how far back the data reaches:
| Period | Use case |
| ------------ | ---------------------------------------------------------------------- |
| **24 Hours** | Triage active, same-day threats and freshly reported IOCs |
| **7 Days** | Review the week's threat activity for weekly briefings or hunting runs |
| **30 Days** | Identify trending campaigns and recurring threat actors over a month |
| **90 Days** | Assess longer-running campaigns and sector-wide threat patterns |
Select a period at the top of the page; the IOC counts and threat data update immediately.
## CISA Critical Infrastructure sectors
The page organizes data according to CISA's 16 Critical Infrastructure sectors. Each sector aggregates IOCs and threat articles that specifically target or are relevant to that vertical — for example, IOCs from campaigns reported to target energy utilities appear under the Energy sector, not in a general pool.
This mapping lets you answer questions like "what threats are actively targeting the Healthcare sector this week?" without manually tagging or filtering a broader feed.
## API access
You can retrieve industry-filtered IOCs programmatically using the `industry` parameter on the IOC endpoint:
```bash theme={null}
curl -H "Authorization: Bearer YOUR_API_KEY" \
"https://socdefenders.ai/api/v1/iocs?industry=healthcare&type=ipv4&limit=100"
```
Combine `industry` with other parameters — `type`, `confidence`, `since` — to build precise queries for your SIEM or threat intelligence platform. The full parameter reference is available in the [API documentation](https://socdefenders.ai/docs/api).
To get your API key, go to **Settings → API Keys** in the platform.
# Looking up and enriching indicators of compromise
Source: https://docs.socdefenders.ai/platform/ioc-lookup
Search any IP, domain, URL, file hash, or CVE in SOC Defenders for AI risk scoring, MITRE ATT&CK techniques, and auto-generated Splunk and KQL hunting queries.
The IOC lookup feature lets you submit a single indicator — an IP address, domain, file hash, CVE, or other artifact — and receive a complete enrichment package in seconds. SOC Defenders scores the indicator using AI, maps it to relevant MITRE ATT\&CK techniques, and generates ready-to-deploy hunting queries for Splunk and Microsoft Sentinel so you can move from investigation to detection without leaving the platform.
## What is an indicator of compromise?
An indicator of compromise (IOC) is an observable artifact — such as a malicious IP address, domain name, or file hash — that signals a potential intrusion or active threat. IOCs are the raw material of threat hunting: by matching them against your environment, you identify systems that may have been targeted or compromised.
## Supported IOC types
SOC Defenders enriches the following indicator types:
| Type | Examples |
| ------------- | ------------------------------------------------------------------ |
| IPv4 | `203.0.113.42` |
| IPv6 | `2001:db8::1` |
| Domain | `malicious-domain.example` |
| URL | `https://malicious-domain.example/payload` |
| MD5 | `d41d8cd98f00b204e9800998ecf8427e` |
| SHA1 | `da39a3ee5e6b4b0d3255bfef95601890afd80709` |
| SHA256 | `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855` |
| CVE | `CVE-2024-12345` |
| MITRE ATT\&CK | `T1059`, `TA0001` |
| Email | `threat-actor@malicious-domain.example` |
## What the enrichment returns
For each indicator you look up, SOC Defenders returns:
* **AI risk score** — a 0–100 score reflecting the indicator's assessed maliciousness
* **Confidence** — low, medium, or high confidence in the risk assessment
* **MITRE ATT\&CK technique mapping** — one or more techniques associated with the indicator's observed behavior
* **Splunk hunting query** — a search query you can paste directly into Splunk to hunt for the indicator in your environment
* **KQL hunting query** — an equivalent query for Microsoft Sentinel / Log Analytics
## Performing a lookup
### Via the platform UI
Navigate to any article that references an IOC. Extracted indicators appear on the article detail page; click any IOC to open the enrichment panel.
### Via the API
Send a `GET` request to `/api/v1/lookup` with the indicator value as a query parameter. Include your API key in the `Authorization` header.
```bash theme={null}
curl -H "Authorization: Bearer YOUR_API_KEY" \
"https://socdefenders.ai/api/v1/lookup?value=203.0.113.42"
```
The response is JSON and includes the risk score, confidence, MITRE mappings, and hunting queries.
## IOC feed filtering
When working with the full IOC feed (`GET /api/v1/iocs`), you can narrow results using these parameters:
| Parameter | Description |
| ------------ | -------------------------------------------------------------------------------------------- |
| `type` | Filter by IOC type: `ipv4`, `ipv6`, `domain`, `url`, `md5`, `sha1`, `sha256`, `cve`, `email` |
| `confidence` | Filter by confidence level: `low`, `medium`, `high` |
| `category` | Filter by source feed category (e.g., `government`, `commercial`) |
| `industry` | Filter to IOCs relevant to a specific CISA Critical Infrastructure sector |
| `since` | Lookback period — restrict results to IOCs observed within a given timeframe |
Free tier accounts have a 1-day lookback period. Pro accounts have access to a 365-day lookback.
# Filtering and browsing the threat news feed
Source: https://docs.socdefenders.ai/platform/news-feed
Use the SOC Defenders news feed to discover cybersecurity articles filtered by category, severity, MITRE ATT&CK, threat actor, industry, and IOC presence.
The SOC Defenders news feed aggregates cybersecurity articles from 30+ sources into a single, continuously updated stream. You can narrow the feed to exactly the signals that matter to your team using a combination of category, severity, IOC presence, threat actor, industry, and technique filters — all without leaving the page.
Filtered results update in real time. As new articles are ingested, they appear immediately in your current filtered view without requiring a page refresh.
## Feed views
At the top of the feed, three views let you control how articles are ranked:
* **Hot** — articles gaining the most engagement right now, weighted by recency and votes
* **New** — articles in chronological order, newest first
* **Top** — all-time highest-voted articles
Switch between views at any time; your active filters carry over.
## Filter categories
Use the **Category** filter to focus the feed on a specific domain of security coverage. Categories are grouped into four areas:
### Threats & Attacks
| Category | Coverage |
| ------------------- | ---------------------------------------------------------- |
| Attacks & Breaches | Reported incidents, data breaches, and intrusion campaigns |
| Vulnerabilities | Disclosed CVEs, advisories, and patch releases |
| Threat Intelligence | IOC feeds, APT reports, and actor tracking |
| Malware | Malware analysis, ransomware, and malicious tooling |
### Defense & Protection
| Category | Coverage |
| -------------------- | ----------------------------------------------------------------- |
| Cloud Security | Cloud misconfigurations, CSP advisories, and cloud-native attacks |
| Endpoint Security | EDR, AV, and host-based threat coverage |
| Network Security | Firewall, IDS/IPS, and network-layer threats |
| Identity & Access | IAM, credential attacks, and authentication weaknesses |
| Application Security | Web app vulnerabilities, SAST/DAST, and API security |
| Data Security | DLP, encryption, and data exfiltration reporting |
### Operations & Compliance
| Category | Coverage |
| ------------------- | ------------------------------------------------------ |
| Security Operations | SOC tooling, detection engineering, and threat hunting |
| Incident Response | IR playbooks, breach timelines, and post-mortems |
| Compliance & Risk | Regulatory updates, frameworks, and risk management |
### Emerging Technologies
| Category | Coverage |
| ----------------- | ----------------------------------------------------------- |
| AI/ML Security | Adversarial ML, LLM attacks, and AI-assisted threats |
| IoT & OT Security | Industrial control systems, embedded device vulnerabilities |
You can select multiple categories at once. The article count next to each category reflects the current match total.
## Severity filter
Filter articles by the CVSS severity of referenced vulnerabilities:
* **Critical** — CVSS 9.0–10.0
* **High** — CVSS 7.0–8.9
* **Medium** — CVSS 4.0–6.9
* **Low** — CVSS 0.1–3.9
Use the **CVSS score range slider** to set a precise minimum and maximum score (0.0–10.0) when you need finer control than the broad severity bands.
## IOC filtering
Toggle **Has IOCs** to show only articles from which SOC Defenders has extracted indicators of compromise — including IP addresses, domains, and file hashes. This is useful when you want to feed results directly into your detection pipeline or IOC enrichment workflow.
Articles without extracted IOCs remain visible by default; enabling the filter hides them.
## Additional filters
| Filter | What it does |
| ----------------- | --------------------------------------------------------------------------------------------- |
| **Threat Actors** | Limit the feed to articles mentioning a specific threat actor or APT group |
| **Date** | Set a date range to focus on recent activity or historical campaigns |
| **Industry** | Show articles relevant to a specific sector (maps to CISA Critical Infrastructure categories) |
| **MITRE ATT\&CK** | Filter by tactic or technique ID (e.g., T1059, TA0001) |
| **Technology** | Narrow results to articles covering a specific vendor, product, or platform |
| **CVE Search** | Search for articles referencing a specific CVE ID |
## Article actions
Each article in the feed exposes the following actions:
* **View** — open the full article detail page, including AI summary, IOCs, and discussion
* **Save** — add the article to your [Saved Articles](/platform/community) list for later review
* **Share** — copy a direct link to the article
* **Comment** — jump to the discussion thread on the article page
# Get started with SOC Defenders
Source: https://docs.socdefenders.ai/quickstart
Sign up for SOC Defenders, create an API key in Settings, and make your first IOC feed request with a working curl command in under five minutes.
This page walks you through creating a SOC Defenders account, generating your first API key, and pulling live threat intelligence from the API. You'll make your first request in under five minutes and leave with a working curl command you can adapt for your own tooling.
The Free tier has a rate limit of 10 requests/minute and 1,000 requests/day. You do not need a credit card to sign up.
Go to [socdefenders.ai](https://socdefenders.ai) and create a free account. No credit card is required. Your account gives you immediate access to the REST API, the threat news feed, IOC lookup, and the CVE database.
After signing in, navigate to **Settings → API Keys** and click **Create key**. Give the key a descriptive name (for example, `my-siem` or `dev-testing`).
Your key is displayed once at creation time. Copy it and store it somewhere secure — you will not be able to view the full key again after leaving the page.
API keys follow the format `sk_live_...`. Free accounts support up to 3 API keys. Pro accounts support up to 50.
Use the following curl command to fetch the 100 most recent IPv4 indicators from the IOC feed. Replace `YOUR_API_KEY` with the key you just created.
```bash theme={null}
curl -H "Authorization: Bearer YOUR_API_KEY" \
"https://socdefenders.ai/api/v1/iocs?type=ipv4&limit=100"
```
A successful response looks like this:
```json theme={null}
{
"meta": { "total": 1523, "limit": 100 },
"data": [
{
"type": "ipv4",
"value": "192.168.1.100",
"confidence": "high",
"source": { "feed_name": "CISA Alerts", "category": "government" }
}
]
}
```
The `meta` object tells you the total number of matching indicators and how many were returned. The `data` array contains the indicators, each with a type, value, confidence rating, and source attribution.
The IOC lookup endpoint enriches a single indicator value with AI risk scoring, MITRE ATT\&CK technique mappings, and auto-generated Splunk and KQL hunting queries. This is useful for incident investigation and triage.
```bash theme={null}
curl -H "Authorization: Bearer YOUR_API_KEY" \
"https://socdefenders.ai/api/v1/lookup?value=192.168.1.100"
```
See the [API reference](/api-reference/iocs/lookup) for the full response schema.
Once you have a working API key, you can:
* Browse [export formats](/formats/overview) to pull data as STIX 2.1, MISP, CEF/Syslog, OpenIOC, or Sigma rules (Pro tier).
* Follow one of the [SIEM integration guides](/integrations/siem-overview) to connect SOC Defenders to Splunk, Microsoft Sentinel, Elastic Security, IBM QRadar, or Google Chronicle.
* Explore the full [API reference](/api-reference/overview) for all available endpoints and query parameters.