Create Analysis

Generate a new analysis for an existing project. Use this endpoint to refresh analysis with updated data, re-analyze after uploading new files, or create additional analysis runs for the same company.

Endpoint

POST https://api.kruncher.ai/api/integration/analysis/company

Headers

Header	Required	Description
`Authorization`	Yes	Your API key (format: `YOUR_API_KEY`)
`Content-Type`	Yes	Must be `application/json`

Request Body

Field	Type	Required	Description
`projectId`	string	Yes	Unique identifier for the project to analyze

Use Cases

When to Create a New Analysis

Updated Information: Company has raised new funding or changed business model
New Documents: After uploading additional pitch decks or financial statements
Refresh Insights: Re-analyze with updated AI models or criteria
Comparative Analysis: Create multiple analysis snapshots over time
Data Changes: After updating company details or entities

Code Examples

JavaScript/TypeScript

Basic

CODE

const API_KEY = "YOUR_API_KEY_HERE";
 
const response = await fetch("https://api.kruncher.ai/api/integration/analysis/company", {
  method: "POST",
  headers: {
    "Authorization": `${API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    projectId: "521a93a6-091d-4943-ba13-7c1a654a14ae"
  })
});
 
const result = await response.json();
console.log("New analysis created:", result.analysisId);
console.log("Project:", result.project);

Result: Creates a new analysis and returns the analysis ID.

With File Upload

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
async function createAnalysisWithFiles(projectId, filePaths) {
  // Step 1: Create analysis
  const analysisResponse = await fetch(`${BASE_URL}/integration/analysis/company`, {
    method: "POST",
    headers: {
      "Authorization": `${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({ projectId })
  });
 
  if (!analysisResponse.ok) {
    throw new Error(`Failed to create analysis: ${analysisResponse.statusText}`);
  }
 
  const { analysisId, project } = await analysisResponse.json();
  console.log("Analysis created:", analysisId);
 
  // Step 2: Upload files for analysis
  const FormData = require('form-data');
  const fs = require('fs');
  
  const form = new FormData();
  filePaths.forEach(filePath => {
    form.append('files', fs.createReadStream(filePath));
  });
 
  const uploadResponse = await fetch(`${BASE_URL}/integrationfiles/upload`, {
    method: "POST",
    headers: {
      "Authorization": `${API_KEY}`,
      "analysisid": analysisId,
      ...form.getHeaders()
    },
    body: form
  });
 
  if (!uploadResponse.ok) {
    throw new Error(`Failed to upload files: ${uploadResponse.statusText}`);
  }
 
  console.log("Files uploaded successfully");
 
  return { analysisId, project };
}
 
// Usage
try {
  const result = await createAnalysisWithFiles(
    "521a93a6-091d-4943-ba13-7c1a654a14ae",
    ["new-pitch-deck.pdf", "updated-financials.xlsx"]
  );
  console.log("Analysis ready:", result.analysisId);
} catch (error) {
  console.error("Error:", error.message);
}

Result: Creates analysis and uploads files in one workflow.

Advanced

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
class KruncherAnalysisManager {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = BASE_URL;
  }
 
  async request(endpoint, options = {}) {
    const url = `${this.baseURL}${endpoint}`;
    const config = {
      headers: {
        "Authorization": `${this.apiKey}`,
        "Content-Type": "application/json",
        ...options.headers
      },
      ...options
    };
 
    const response = await fetch(url, config);
 
    if (!response.ok) {
      const error = await response.json().catch(() => ({ 
        message: response.statusText 
      }));
      throw new Error(`API Error: ${error.message || error.description}`);
    }
 
    return await response.json();
  }
 
  async createAnalysis(projectId) {
    return await this.request('/integration/analysis/company', {
      method: 'POST',
      body: JSON.stringify({ projectId })
    });
  }
 
  async uploadFiles(analysisId, filePaths) {
    const FormData = require('form-data');
    const fs = require('fs');
    
    const form = new FormData();
    filePaths.forEach(filePath => {
      form.append('files', fs.createReadStream(filePath));
    });
 
    const response = await fetch(`${this.baseURL}/integrationfiles/upload`, {
      method: "POST",
      headers: {
        "Authorization": `${this.apiKey}`,
        "analysisid": analysisId,
        ...form.getHeaders()
      },
      body: form
    });
 
    if (!response.ok) {
      throw new Error(`Upload failed: ${response.statusText}`);
    }
 
    return await response.json();
  }
 
  async checkAnalysisStatus(analysisId) {
    const result = await this.request('/integration/projects');
    
    for (const project of result.data) {
      const analysis = project.analyses?.find(a => a.id === analysisId);
      if (analysis) {
        return {
          status: analysis.status,
          type: analysis.type,
          createdAt: analysis.createdAt,
          project: project
        };
      }
    }
    
    throw new Error(`Analysis ${analysisId} not found`);
  }
 
  async waitForAnalysis(analysisId, maxWaitMs = 300000, pollIntervalMs = 5000) {
    const startTime = Date.now();
    
    while (Date.now() - startTime < maxWaitMs) {
      const status = await this.checkAnalysisStatus(analysisId);
      
      console.log(`Analysis status: ${status.status}`);
      
      if (status.status === 'completed') {
        return status;
      }
      
      if (status.status === 'failed') {
        throw new Error('Analysis failed');
      }
      
      await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
    }
    
    throw new Error('Analysis timeout');
  }
 
  async createAnalysisWithFiles(projectId, filePaths = []) {
    // Create analysis
    const { analysisId, project } = await this.createAnalysis(projectId);
    console.log(`✓ Analysis created: ${analysisId}`);
 
    // Upload files if provided
    if (filePaths.length > 0) {
      await this.uploadFiles(analysisId, filePaths);
      console.log(`✓ Uploaded ${filePaths.length} file(s)`);
    }
 
    // Wait for completion
    console.log('⏳ Waiting for analysis to complete...');
    const finalStatus = await this.waitForAnalysis(analysisId);
    console.log('✓ Analysis completed');
 
    return {
      analysisId,
      project,
      status: finalStatus
    };
  }
 
  async refreshAnalysis(projectId) {
    console.log('Creating new analysis for existing project...');
    const result = await this.createAnalysis(projectId);
    
    console.log('Waiting for analysis...');
    await this.waitForAnalysis(result.analysisId);
    
    return result;
  }
}
 
// Usage examples
const manager = new KruncherAnalysisManager("YOUR_API_KEY_HERE");
 
// Create analysis without files
const analysis1 = await manager.createAnalysis("521a93a6-091d-4943-ba13-7c1a654a14ae");
console.log("Analysis ID:", analysis1.analysisId);
 
// Create analysis with files and wait for completion
const analysis2 = await manager.createAnalysisWithFiles(
  "521a93a6-091d-4943-ba13-7c1a654a14ae",
  ["pitch-deck.pdf", "financials.xlsx"]
);
console.log("Completed analysis:", analysis2);
 
// Refresh existing project analysis
const refreshed = await manager.refreshAnalysis("521a93a6-091d-4943-ba13-7c1a654a14ae");
console.log("Refreshed analysis:", refreshed.analysisId);
 
// Check analysis status
const status = await manager.checkAnalysisStatus(analysis1.analysisId);
console.log("Status:", status.status);

Result: Full-featured manager with status polling and file upload.

Python

Basic

CODE

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
url = "https://api.kruncher.ai/api/integration/analysis/company"
 
headers = {
    "Authorization": f"{API_KEY}",
    "Content-Type": "application/json"
}
 
data = {
    "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae"
}
 
response = requests.post(url, headers=headers, json=data)
 
if response.status_code == 200:
    result = response.json()
    print(f"Analysis created: {result['analysisId']}")
    print(f"Project: {result['project']['name']}")
else:
    print(f"Error: {response.status_code} {response.text}")

Result: Creates a new analysis for the project.

With File Upload

CODE

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
def create_analysis_with_files(project_id, file_paths):
    """Create analysis and upload files."""
    headers = {
        "Authorization": f"{API_KEY}",
        "Content-Type": "application/json"
    }
    
    # Step 1: Create analysis
    analysis_response = requests.post(
        f"{BASE_URL}/integration/analysis/company",
        headers=headers,
        json={"projectId": project_id}
    )
    analysis_response.raise_for_status()
    
    result = analysis_response.json()
    analysis_id = result['analysisId']
    print(f"Analysis created: {analysis_id}")
    
    # Step 2: Upload files
    if file_paths:
        upload_headers = {
            "Authorization": f"{API_KEY}",
            "analysisid": analysis_id
        }
        
        files = [
            ("files", (open(file_path, "rb")))
            for file_path in file_paths
        ]
        
        upload_response = requests.post(
            f"{BASE_URL}/integrationfiles/upload",
            headers=upload_headers,
            files=files
        )
        upload_response.raise_for_status()
        
        print(f"Uploaded {len(file_paths)} file(s)")
    
    return result
 
# Usage
try:
    result = create_analysis_with_files(
        "521a93a6-091d-4943-ba13-7c1a654a14ae",
        ["new-pitch-deck.pdf", "updated-financials.xlsx"]
    )
    print(f"Analysis ready: {result['analysisId']}")
except Exception as e:
    print(f"Error: {e}")

Result: Creates analysis and uploads files together.

Advanced

CODE

import requests
import time
from typing import Dict, List, Optional
from dataclasses import dataclass
from pathlib import Path
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
@dataclass
class AnalysisStatus:
    analysis_id: str
    status: str
    type: str
    created_at: str
    project: Dict
 
class KruncherAnalysisManager:
    """Python client for managing Kruncher analyses."""
    
    def __init__(self, api_key: str = API_KEY):
        self.api_key = api_key
        self.base_url = BASE_URL
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"{api_key}",
            "Content-Type": "application/json"
        })
    
    def create_analysis(self, project_id: str) -> Dict:
        """
        Create a new analysis for a project.
        
        Args:
            project_id: The project ID
        
        Returns:
            Dict with analysisId and project data
        
        Raises:
            requests.HTTPError: If request fails
        """
        response = self.session.post(
            f"{self.base_url}/integration/analysis/company",
            json={"projectId": project_id}
        )
        response.raise_for_status()
        return response.json()
    
    def upload_files(self, analysis_id: str, file_paths: List[str]) -> Dict:
        """
        Upload files to an analysis.
        
        Args:
            analysis_id: The analysis ID
            file_paths: List of file paths to upload
        
        Returns:
            Upload response dict
        """
        headers = {
            "Authorization": f"{self.api_key}",
            "analysisid": analysis_id
        }
        
        file_handles = []
        files_list = []
        
        try:
            for file_path in file_paths:
                file_handle = open(file_path, "rb")
                file_handles.append(file_handle)
                filename = Path(file_path).name
                files_list.append(("files", (filename, file_handle)))
            
            response = requests.post(
                f"{self.base_url}/integrationfiles/upload",
                headers=headers,
                files=files_list
            )
            response.raise_for_status()
            return response.json()
        finally:
            for file_handle in file_handles:
                file_handle.close()
    
    def check_analysis_status(self, analysis_id: str) -> AnalysisStatus:
        """
        Check the status of an analysis.
        
        Args:
            analysis_id: The analysis ID
        
        Returns:
            AnalysisStatus object
        
        Raises:
            ValueError: If analysis not found
        """
        response = self.session.get(f"{self.base_url}/integration/projects")
        response.raise_for_status()
        
        result = response.json()
        
        for project in result.get('data', []):
            for analysis in project.get('analyses', []):
                if analysis['id'] == analysis_id:
                    return AnalysisStatus(
                        analysis_id=analysis['id'],
                        status=analysis['status'],
                        type=analysis['type'],
                        created_at=analysis['createdAt'],
                        project=project
                    )
        
        raise ValueError(f"Analysis {analysis_id} not found")
    
    def wait_for_analysis(
        self,
        analysis_id: str,
        max_wait_seconds: int = 300,
        poll_interval_seconds: int = 5
    ) -> AnalysisStatus:
        """
        Wait for analysis to complete.
        
        Args:
            analysis_id: The analysis ID
            max_wait_seconds: Maximum time to wait
            poll_interval_seconds: Time between status checks
        
        Returns:
            AnalysisStatus when completed
        
        Raises:
            TimeoutError: If analysis doesn't complete in time
            RuntimeError: If analysis fails
        """
        start_time = time.time()
        
        while time.time() - start_time < max_wait_seconds:
            status = self.check_analysis_status(analysis_id)
            
            print(f"Analysis status: {status.status}")
            
            if status.status == 'completed':
                return status
            
            if status.status == 'failed':
                raise RuntimeError('Analysis failed')
            
            time.sleep(poll_interval_seconds)
        
        raise TimeoutError(f"Analysis did not complete within {max_wait_seconds} seconds")
    
    def create_analysis_with_files(
        self,
        project_id: str,
        file_paths: Optional[List[str]] = None,
        wait: bool = True
    ) -> Dict:
        """
        Create analysis and optionally upload files.
        
        Args:
            project_id: The project ID
            file_paths: Optional list of files to upload
            wait: Whether to wait for analysis completion
        
        Returns:
            Dict with analysis info and status
        """
        # Create analysis
        result = self.create_analysis(project_id)
        analysis_id = result['analysisId']
        print(f"✓ Analysis created: {analysis_id}")
        
        # Upload files if provided
        if file_paths:
            self.upload_files(analysis_id, file_paths)
            print(f"✓ Uploaded {len(file_paths)} file(s)")
        
        # Wait for completion if requested
        if wait:
            print("⏳ Waiting for analysis to complete...")
            final_status = self.wait_for_analysis(analysis_id)
            print("✓ Analysis completed")
            result['status'] = final_status
        
        return result
    
    def refresh_analysis(self, project_id: str) -> Dict:
        """
        Refresh analysis for an existing project.
        
        Args:
            project_id: The project ID
        
        Returns:
            New analysis result
        """
        print("Creating new analysis for existing project...")
        result = self.create_analysis(project_id)
        
        print("Waiting for analysis...")
        self.wait_for_analysis(result['analysisId'])
        
        return result
 
# Usage examples
manager = KruncherAnalysisManager()
 
# Create analysis without files
result = manager.create_analysis("521a93a6-091d-4943-ba13-7c1a654a14ae")
print(f"Analysis ID: {result['analysisId']}")
 
# Create analysis with files and wait
result = manager.create_analysis_with_files(
    "521a93a6-091d-4943-ba13-7c1a654a14ae",
    ["pitch-deck.pdf", "financials.xlsx"],
    wait=True
)
print(f"Completed analysis: {result['analysisId']}")
 
# Refresh existing project
refreshed = manager.refresh_analysis("521a93a6-091d-4943-ba13-7c1a654a14ae")
print(f"Refreshed analysis: {refreshed['analysisId']}")
 
# Check analysis status
status = manager.check_analysis_status(result['analysisId'])
print(f"Status: {status.status}")
print(f"Type: {status.type}")
print(f"Created: {status.created_at}")

Result: Production-ready manager with status polling and file handling.

cURL

Basic

CODE

curl -X POST "https://api.kruncher.ai/api/integration/analysis/company" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae"
  }'

With jq

CODE

# Create analysis and extract analysisId
ANALYSIS_ID=$(curl -X POST "https://api.kruncher.ai/api/integration/analysis/company" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae"
  }' | jq -r '.analysisId')
 
echo "Analysis ID: $ANALYSIS_ID"

Full Workflow

CODE

#!/bin/bash
 
API_KEY="YOUR_API_KEY_HERE"
PROJECT_ID="521a93a6-091d-4943-ba13-7c1a654a14ae"
 
# Create analysis
echo "Creating analysis..."
RESPONSE=$(curl -s -X POST "https://api.kruncher.ai/api/integration/analysis/company" \
  -H "Authorization: $API_KEY" \
  -H "Content-Type: application/json" \
  -d "{\"projectId\": \"$PROJECT_ID\"}")
 
ANALYSIS_ID=$(echo $RESPONSE | jq -r '.analysisId')
echo "Analysis created: $ANALYSIS_ID"
 
# Upload files
echo "Uploading files..."
curl -X POST "https://api.kruncher.ai/api/integrationfiles/upload" \
  -H "Authorization: $API_KEY" \
  -H "analysisid: $ANALYSIS_ID" \
  -F "files=@pitch-deck.pdf" \
  -F "files=@financials.xlsx"
 
echo "Files uploaded. Analysis in progress..."

Response

Success Response (200 OK)

CODE

{
  "code": "1000",
  "title": "Success",
  "description": "Analysis created successfully",
  "analysisId": "analysis_xyz789",
  "project": {
    "id": "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "name": "TechStartup",
    "companyName": "TechStartup Inc.",
    "companyWebsite": "https://techstartup.com"
  }
}

Error Responses

400 Bad Request

CODE

{
  "code": "4000",
  "title": "Bad Request",
  "description": "Invalid project ID"
}

404 Not Found

CODE

{
  "code": "4040",
  "title": "Not Found",
  "description": "Project not found"
}

Common Workflows

Workflow 1: Refresh Analysis After Data Update

CODE

// After updating company data
await updateAnalysisEntity(analysisId, "revenue", 10000000);
await updateAnalysisEntity(analysisId, "employees", 75);
 
// Create new analysis to refresh insights
const newAnalysis = await manager.createAnalysis(projectId);
await manager.waitForAnalysis(newAnalysis.analysisId);
 
console.log("Analysis refreshed with new data");

Workflow 2: Analyze New Documents

CODE

# Upload new pitch deck and create fresh analysis
manager = KruncherAnalysisManager()
 
result = manager.create_analysis_with_files(
    project_id="521a93a6-091d-4943-ba13-7c1a654a14ae",
    file_paths=["Q4-2024-deck.pdf", "updated-metrics.xlsx"],
    wait=True
)
 
print(f"New analysis completed: {result['analysisId']}")

Workflow 3: Periodic Re-Analysis

CODE

import schedule
import time
 
def refresh_all_projects():
    """Refresh analysis for all active projects."""
    manager = KruncherAnalysisManager()
    
    # Get all projects
    response = manager.session.get(f"{manager.base_url}/integration/projects")
    projects = response.json()['data']
    
    for project in projects:
        if project.get('processing') == 'completed':
            print(f"Refreshing {project['name']}...")
            try:
                manager.create_analysis(project['id'])
            except Exception as e:
                print(f"Failed to refresh {project['name']}: {e}")
 
# Schedule weekly refresh
schedule.every().monday.at("09:00").do(refresh_all_projects)
 
while True:
    schedule.run_pending()
    time.sleep(3600)

Analysis Status

After creating an analysis, it will go through several status stages:

Status	Description
`pending`	Analysis queued, not started yet
`progress`	Analysis currently running
`completed`	Analysis finished successfully
`failed`	Analysis encountered an error

You can check status using the Find Companies endpoint and looking at the analyses array.

Best Practices

Check Before Creating

Verify project exists before creating analysis
Check if current analysis is still in progress
Consider rate limits for bulk analysis creation

File Uploads

Upload files immediately after creating analysis
Use the returned analysisId for file uploads
Don’t wait for first analysis to complete before uploading

Status Polling

Poll every 5-10 seconds for status updates
Implement timeout for long-running analyses
Handle failed analyses gracefully

Error Handling

Validate project ID exists
Check response status before proceeding
Implement retry logic for transient failures

Create Company - Create a project first
Upload Files - Upload documents for analysis
Find Companies - Check analysis status
Update Analysis - Update analysis data

Troubleshooting

”Project not found”

Verify the project ID is correct
Ensure project hasn’t been deleted
Check you have access to the project

Analysis Stuck in “progress”

Wait up to 5 minutes for completion
Check file upload completed successfully
Contact support if stuck longer than 10 minutes

Multiple Analyses

Each analysis creates a new record
Old analyses remain accessible
Use createdAt to identify latest analysis

Need Help?

Bulk analysis? Contact support for batch processing
Long processing? Check file sizes and formats
Integration issues? Review the workflow examples above

Create Analysis

Endpoint

Headers

Request Body

Use Cases

When to Create a New Analysis

Code Examples

JavaScript/TypeScript

Basic

With File Upload

Advanced

Python

Basic

With File Upload

Advanced

cURL

Basic

With jq

Full Workflow

Response

Success Response (200 OK)

Error Responses

400 Bad Request

404 Not Found

Common Workflows

Workflow 1: Refresh Analysis After Data Update

Workflow 2: Analyze New Documents

Workflow 3: Periodic Re-Analysis

Analysis Status

Best Practices

Check Before Creating

File Uploads

Status Polling

Error Handling

Related Endpoints

Troubleshooting

”Project not found”

Analysis Stuck in “progress”

Multiple Analyses

Need Help?