Enterprise Batch Operations

The enterprise batch endpoint allows you to retrieve up to 50 CVEs in a single POST request with advanced features, delivering 86% cost savings and superior performance compared to individual calls.

Overview

Enterprise Batch Endpoint: POST /api/v1/cve/batch

Replace dozens of individual API calls with a single, powerful batch operation that includes:

• Flat-rate pricing: 35 credits for 1-50 CVEs (vs 250 credits for 50 individual calls)
• Advanced filtering: Field selection, enrichment options, sorting
• Enterprise features: Comprehensive threat intelligence in one request
• No rate limits: Process large datasets at full speed
• Atomic operations: Consistent data snapshot across all CVEs

Enterprise Value Proposition

• Cost Savings: 86% reduction in credit consumption (35 vs 250 credits)
• Performance: Single request vs 50 HTTP round trips
• Advanced Features: Field selection, enrichment data, comprehensive threat intelligence
• Scalability: No rate limits on paid plans for high-volume processing
• Data Consistency: Atomic snapshot across all requested CVEs
• Bandwidth Efficiency: Single JSON response vs 50 separate API calls

Enterprise Batch Endpoint Usage

Basic POST Request

Cost: 35 credits (flat rate for 1-50 CVEs)

# Basic batch request - comprehensive CVE data
curl -X POST -H "X-API-Key: your-api-key-here" \
     -H "Content-Type: application/json" \
     -d '{"cve_ids": ["CVE-2024-0001", "CVE-2024-0002", "CVE-2024-0003"]}' \
     https://api.cybersecfeed.com/api/v1/cve/batch

# With enrichment data included
curl -X POST -H "X-API-Key: your-api-key-here" \
     -H "Content-Type: application/json" \
     -d '{"cve_ids": ["CVE-2024-0001", "CVE-2024-0002"], "include": "enrichment"}' \
     https://api.cybersecfeed.com/api/v1/cve/batch

Advanced Features

# Field selection for optimized responses (reduce payload by up to 85%)
curl -X POST -H "X-API-Key: your-api-key-here" \
     -H "Content-Type: application/json" \
     -d '{
       "cve_ids": ["CVE-2021-44228", "CVE-2024-0001"],
       "fields": ["cve_id", "severity", "kev", "epss"],
       "include": "enrichment"
     }' \
     https://api.cybersecfeed.com/api/v1/cve/batch

Request Specifications

• Maximum: 50 CVE IDs per request
• Format: JSON array of CVE ID strings
• Invalid IDs: Returned in not_found array with details
• Cost: Flat 35 credits regardless of 1-50 CVEs requested
• Response Format: Structured JSON with comprehensive metadata

Implementation Examples

Python

import requests

def enterprise_batch_cves(cve_ids, api_key, fields=None, include=None):
    """
    Enterprise batch CVE lookup with advanced features

    Args:
        cve_ids: List of CVE IDs (max 50)
        api_key: Your API key
        fields: List of fields to include (optional, reduces payload)
        include: Enrichment data to include (enrichment, acsc, attack)

    Returns:
        Dictionary with comprehensive CVE data
        Cost: 35 credits (flat rate)
    """
    url = "https://api.cybersecfeed.com/api/v1/cve/batch"
    headers = {
        "X-API-Key": api_key,
        "Content-Type": "application/json"
    }

    # Build request payload
    payload = {"cve_ids": cve_ids[:50]}  # Limit to 50

    if fields:
        payload["fields"] = fields
    if include:
        payload["include"] = include

    response = requests.post(url, json=payload, headers=headers)

    return response.json()

# Example usage - 86% cost savings!
cve_list = [
    "CVE-2021-44228",  # Log4Shell
    "CVE-2024-0001",
    "CVE-2024-0002",
    "CVE-2024-0003",
    "CVE-2024-0004"
]

# Basic enterprise batch (35 credits vs 250 for individual calls)
result = enterprise_batch_cves(cve_list, "your-api-key-here")

# Optimized with field selection (85% payload reduction)
result_optimized = enterprise_batch_cves(
    cve_list,
    "your-api-key-here",
    fields=["cve_id", "severity", "kev", "epss"],
    include="enrichment"
)

# Complete threat intelligence package
result_full = enterprise_batch_cves(
    cve_list,
    "your-api-key-here",
    include="enrichment,acsc,attack"
)

Processing Large Lists

When you have more than 50 CVEs, process them in enterprise batches for maximum efficiency:

def process_large_cve_list_enterprise(all_cve_ids, api_key, fields=None, include=None):
    """
    Process large CVE lists with enterprise batch endpoint

    Args:
        all_cve_ids: List of all CVE IDs to process
        api_key: Your API key
        fields: Field selection for payload optimization
        include: Enrichment data to include

    Returns:
        List of all CVE data with cost tracking
    """
    batch_size = 50
    all_results = []
    total_credits = 0

    # Calculate batches and costs
    num_batches = len(all_cve_ids) // batch_size + (1 if len(all_cve_ids) % batch_size else 0)
    estimated_credits = num_batches * 35  # Flat rate per batch

    print(f"Processing {len(all_cve_ids)} CVEs in {num_batches} batches")
    print(f"Estimated cost: {estimated_credits} credits (vs {len(all_cve_ids) * 5} for individual calls)")
    print(f"Cost savings: {((len(all_cve_ids) * 5 - estimated_credits) / (len(all_cve_ids) * 5)) * 100:.1f}%")

    # Process in enterprise batches
    for i in range(0, len(all_cve_ids), batch_size):
        batch = all_cve_ids[i:i + batch_size]

        # Enterprise batch request (35 credits)
        result = enterprise_batch_cves(batch, api_key, fields, include)

        # Track results and credits
        if result.get("data", {}).get("cves"):
            batch_cves = list(result["data"]["cves"].values())
            all_results.extend(batch_cves)
            total_credits += 35

            print(f"Batch {i//batch_size + 1}/{num_batches}: {len(batch_cves)} CVEs retrieved")

    print(f"\nTotal: {len(all_results)} CVEs, {total_credits} credits used")
    return all_results

# Example: Process 200 CVEs with maximum efficiency
large_cve_list = [f"CVE-2024-{str(i).zfill(4)}" for i in range(1, 201)]

# Enterprise processing with field optimization
all_cves = process_large_cve_list_enterprise(
    large_cve_list,
    "your-api-key-here",
    fields=["cve_id", "severity", "kev", "epss"],  # 85% payload reduction
    include="enrichment"  # Full threat intelligence
)

# Cost comparison:
# Individual calls: 200 × 5 = 1,000 credits
# Enterprise batch: 4 × 35 = 140 credits (86% savings!)

JavaScript/Node.js

async function enterpriseBatchCVEs(cveIds, apiKey, options = {}) {
	const url = 'https://api.cybersecfeed.com/api/v1/cve/batch';
	const headers = {
		'X-API-Key': apiKey,
		'Content-Type': 'application/json',
	};

	// Build enterprise batch payload
	const payload = {
		cve_ids: cveIds.slice(0, 50), // Limit to 50
	};

	// Add advanced features
	if (options.fields) payload.fields = options.fields;
	if (options.include) payload.include = options.include;

	const response = await fetch(url, {
		method: 'POST',
		headers: headers,
		body: JSON.stringify(payload),
	});

	return await response.json();
}

// Enterprise batch processing with cost tracking
async function processLargeCVEListEnterprise(allCveIds, apiKey, options = {}) {
	const batchSize = 50;
	const allResults = [];
	let totalCredits = 0;

	const numBatches = Math.ceil(allCveIds.length / batchSize);
	const estimatedCredits = numBatches * 35;
	const individualCredits = allCveIds.length * 5;
	const savings = (((individualCredits - estimatedCredits) / individualCredits) * 100).toFixed(1);

	console.log(`Processing ${allCveIds.length} CVEs in ${numBatches} enterprise batches`);
	console.log(`Cost: ${estimatedCredits} credits (vs ${individualCredits} individual calls)`);
	console.log(`Savings: ${savings}% cost reduction`);

	for (let i = 0; i < allCveIds.length; i += batchSize) {
		const batch = allCveIds.slice(i, i + batchSize);
		const result = await enterpriseBatchCVEs(batch, apiKey, options);

		if (result.data && result.data.cves) {
			const batchCves = Object.values(result.data.cves);
			allResults.push(...batchCves);
			totalCredits += 35; // Flat rate per batch

			console.log(`Batch ${Math.floor(i / batchSize) + 1}/${numBatches}: ${batchCves.length} CVEs`);
		}
	}

	console.log(`\nCompleted: ${allResults.length} CVEs, ${totalCredits} credits used`);
	return allResults;
}

// Example usage with enterprise features
const cveList = ['CVE-2021-44228', 'CVE-2024-0001', 'CVE-2024-0002'];

// Basic enterprise batch (35 credits)
const basicResults = await enterpriseBatchCVEs(cveList, 'your-api-key-here');

// Optimized with field selection and enrichment
const optimizedResults = await enterpriseBatchCVEs(cveList, 'your-api-key-here', {
	fields: ['cve_id', 'severity', 'kev', 'epss'],
	include: 'enrichment,attack',
});

// Large-scale processing
const largeCveList = Array.from({ length: 200 }, (_, i) => `CVE-2024-${String(i + 1).padStart(4, '0')}`);
const results = await processLargeCVEListEnterprise(largeCveList, 'your-api-key-here', {
	fields: ['cve_id', 'severity', 'kev'],
	include: 'enrichment',
});

Best Practices

1. Validate IDs Before Sending

import re

def validate_cve_id(cve_id):
    """Validate CVE ID format"""
    pattern = r'^CVE-\d{4}-\d{4,}$'
    return bool(re.match(pattern, cve_id))

# Filter valid IDs only
valid_ids = [cve_id for cve_id in cve_list if validate_cve_id(cve_id)]

2. Handle Missing CVEs

Not all requested CVEs may exist in the response:

def check_missing_cves(requested_ids, response_data):
    """Identify which CVEs were not found"""
    returned_ids = {cve["id"] for cve in response_data["data"]["cves"]}
    missing_ids = set(requested_ids) - returned_ids

    if missing_ids:
        print(f"CVEs not found: {missing_ids}")

    return missing_ids

3. Enterprise Field Selection & Enrichment

Maximize value with advanced features (same 35 credit cost):

# Essential fields only (85% payload reduction)
curl -X POST -H "X-API-Key: your-api-key-here" \
     -H "Content-Type: application/json" \
     -d '{
       "cve_ids": ["CVE-2024-0001", "CVE-2024-0002"],
       "fields": ["cve_id", "severity", "kev", "epss"]
     }' \
     https://api.cybersecfeed.com/api/v1/cve/batch

# Complete threat intelligence package
curl -X POST -H "X-API-Key: your-api-key-here" \
     -H "Content-Type: application/json" \
     -d '{
       "cve_ids": ["CVE-2024-0001", "CVE-2024-0002"],
       "include": "enrichment,acsc,attack"
     }' \
     https://api.cybersecfeed.com/api/v1/cve/batch

# Maximum optimization: field selection + comprehensive enrichment
curl -X POST -H "X-API-Key: your-api-key-here" \
     -H "Content-Type: application/json" \
     -d '{
       "cve_ids": ["CVE-2021-44228", "CVE-2024-0001"],
       "fields": ["cve_id", "severity", "kev", "epss", "enrichment_status"],
       "include": "enrichment,attack"
     }' \
     https://api.cybersecfeed.com/api/v1/cve/batch

4. Enterprise Error Handling

def safe_enterprise_batch(cve_ids, api_key, fields=None, include=None, max_retries=3):
    """Enterprise batch with retry logic and cost tracking"""
    for attempt in range(max_retries):
        try:
            result = enterprise_batch_cves(cve_ids, api_key, fields, include)

            if result.get("data"):
                # Log cost efficiency
                requested = len(cve_ids)
                found = result['data']['count']
                not_found = result['data'].get('not_found', [])

                print(f"Batch complete: {found}/{requested} CVEs found, 35 credits used")
                if not_found:
                    print(f"Not found: {not_found}")

                return result

        except Exception as e:
            print(f"Attempt {attempt + 1} failed: {e}")
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)  # Exponential backoff

    return None

Enterprise Performance Metrics

Method	CVEs	Credits	Time	Cost Savings	Features
Individual Calls	50	250	~25 seconds	0%	Basic CVE data
Enterprise Batch	50	35	~0.5 sec	86%	Full threat intelligence
Enterprise + Field Select	50	35	~0.3 sec	86%	Optimized payload
Enterprise + Enrichment	50	35	~0.6 sec	86%	Complete analysis

Real-World Scaling

CVE Count	Individual Credits	Enterprise Credits	Time Savings	Cost Savings
100	500	70 (2 batches)	95%	86%
500	2,500	350 (10 batches)	98%	86%
1,000	5,000	700 (20 batches)	98%	86%
5,000	25,000	3,500 (100 batches)	99%	86%

Enterprise Features Performance Impact

Configuration	Response Size	Processing Time	Credits	Use Case
Basic batch	~2KB per CVE	Fastest	35	Basic vulnerability assessment
+ Field selection	~0.3KB per CVE	85% faster	35	Optimized bandwidth
+ Enrichment	~3KB per CVE	+20% slower	35	Advanced threat intelligence
+ Complete (enrich+acsc+attack)	~4KB per CVE	+40% slower	35	Comprehensive analysis
All features	~1KB per CVE	Optimized	35	Maximum value enterprise

Key Insight: Field selection with enrichment provides the best value - comprehensive data with optimized performance, all for the same 35 credit cost.

Enterprise Use Cases

1. Security Operations Center (SOC)

# Real-time threat monitoring - 86% cost savings
critical_cves = get_critical_cves_from_feed()
result = enterprise_batch_cves(
    critical_cves,
    api_key,
    fields=["cve_id", "severity", "kev", "epss"],
    include="enrichment,attack"
)
# Cost: 35 credits vs 250 for individual calls

2. Vulnerability Management

# Weekly vulnerability assessment
inventory_cves = scan_software_inventory()
for batch in chunk_list(inventory_cves, 50):
    result = enterprise_batch_cves(
        batch,
        api_key,
        include="enrichment"  # Full threat context
    )
    # 35 credits per 50 CVEs (86% savings)

3. Compliance Reporting

# Quarterly compliance report
audit_cves = get_audit_scope_cves()
comprehensive_data = enterprise_batch_cves(
    audit_cves,
    api_key,
    include="enrichment,acsc,attack"  # Complete documentation
)
# Full compliance data at enterprise efficiency

4. Threat Intelligence Integration

# CTI feed processing
ti_cves = parse_threat_intelligence_feed()
for batch in chunk_list(ti_cves, 50):
    intel = enterprise_batch_cves(
        batch,
        api_key,
        fields=["cve_id", "severity", "kev", "epss", "enrichment_status"],
        include="attack"  # ATT&CK mapping for threat hunting
    )
    # Enrich TI feeds with attack techniques

5. Risk-Based Prioritization

# Executive risk dashboard
high_risk_cves = filter_high_risk_cves()
risk_data = enterprise_batch_cves(
    high_risk_cves,
    api_key,
    fields=["cve_id", "severity", "kev", "epss"],  # Risk factors only
    include="enrichment"  # Exploitation context
)
# Fast, cost-effective risk assessment

Enterprise Optimization Strategies

• Maximum Speed: Field selection with essential data only (cve_id, severity, kev)
• Maximum Value: Complete enrichment with field optimization
• Regional Intelligence: Include ACSC data for Australian/APAC threat context
• Threat Hunting: ATT&CK technique mapping with enrichment data
• Cost Efficiency: Always use batch operations - 86% savings guaranteed
• Performance: Field selection reduces payload by up to 85%

Enterprise Transformation Summary

The enterprise batch endpoint represents a paradigm shift from traditional API usage to value-based intelligence operations:

Cost Revolution

• 86% cost reduction: 35 credits vs 250 for 50 CVEs
• Flat-rate pricing: Predictable costs regardless of 1-50 CVE requests
• Enterprise scaling: Massive savings on large-scale operations

Performance Advantages

• Single request: Eliminate dozens of HTTP round trips
• Field selection: Up to 85% payload reduction
• No rate limits: Process at maximum system speed
• Atomic operations: Consistent data snapshots

Intelligence Features

• Comprehensive enrichment: Full threat intelligence in one call
• ATT&CK mapping: Attack technique identification
• ACSC integration: Regional threat context
• Advanced filtering: Precise data extraction

Enterprise Best Practices

1. Always use batch operations for multiple CVE analysis - 86% savings guaranteed
2. Leverage field selection to optimize bandwidth and processing time
3. Include comprehensive enrichment - same 35 credit cost for basic or full data
4. Scale with confidence - no rate limits on paid plans
5. Monitor cost efficiency - track credits per business outcome

Strategic Impact: Transform from individual API calls to enterprise intelligence operations, achieving massive cost savings while gaining superior threat intelligence capabilities.

Migration Path: Replace all multi-CVE operations with enterprise batch endpoint - immediate 86% cost reduction with enhanced features.