Retrieve Companies

Retrieve all companies in your portfolio with detailed information including analysis results, scores, project status, and owner details. Results are paginated for efficient data handling.

Endpoint

GET https://api.kruncher.ai/api/integration/projects

Headers

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

Query Parameters

Parameter	Type	Required	Description
`page`	integer	No	Page number (0-indexed, default: 0)
`orderby`	string	No	Field name to sort by (ascending)

Code Examples

JavaScript/TypeScript

Basic

CODE

const API_KEY = "YOUR_API_KEY_HERE";
 
const response = await fetch("https://api.kruncher.ai/api/integration/projects", {
  method: "GET",
  headers: {
    "Authorization": `${API_KEY}`,
    "Content-Type": "application/json"
  }
});
 
const data = await response.json();
console.log(`Found ${data.pagination.totalCount} companies`);
console.log("Companies:", data.data);

Result: Retrieves first page of companies with default pagination.

With Pagination

CODE

const API_KEY = "YOUR_API_KEY_HERE";
 
async function getAllCompanies(pageSize = 50) {
  let allCompanies = [];
  let currentPage = 1;
  let hasMore = true;
 
  while (hasMore) {
    const response = await fetch(
      `https://api.kruncher.ai/api/integration/projects?page=${currentPage}&pageSize=${pageSize}`,
      {
        headers: {
          "Authorization": `${API_KEY}`,
          "Content-Type": "application/json"
        }
      }
    );
 
    const result = await response.json();
    allCompanies = allCompanies.concat(result.data);
    
    hasMore = result.pagination.nextPage;
    currentPage++;
    
    console.log(`Fetched page ${currentPage - 1}: ${result.data.length} companies`);
  }
 
  return allCompanies;
}
 
// Usage
const companies = await getAllCompanies();
console.log(`Total companies retrieved: ${companies.length}`);

Result: Retrieves all companies across multiple pages.

Advanced

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
class KruncherCompanyAPI {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = BASE_URL;
  }
 
  async request(endpoint, params = {}) {
    const queryString = new URLSearchParams(params).toString();
    const url = `${this.baseURL}${endpoint}${queryString ? `?${queryString}` : ''}`;
 
    const response = await fetch(url, {
      headers: {
        "Authorization": `${this.apiKey}`,
        "Content-Type": "application/json"
      }
    });
 
    if (!response.ok) {
      throw new Error(`API Error: ${response.status} ${response.statusText}`);
    }
 
    return await response.json();
  }
 
  async getCompanies(options = {}) {
    const { page = 1, pageSize = 20, search, status } = options;
    
    const params = { page, pageSize };
    if (search) params.search = search;
    if (status) params.status = status;
 
    return await this.request('/integration/projects', params);
  }
 
  async getCompanyById(companyId) {
    const result = await this.getCompanies();
    return result.data.find(company => company.id === companyId);
  }
 
  async getCompletedAnalyses() {
    const result = await this.getCompanies();
    return result.data.filter(company => 
      company.analyses?.some(analysis => analysis.status === 'completed')
    );
  }
 
  async getCompaniesByScore(minScore) {
    const result = await this.getCompanies();
    return result.data.filter(company =>
      company.projectscores?.some(score => score.score >= minScore)
    );
  }
}
 
// Usage
const api = new KruncherCompanyAPI("YOUR_API_KEY_HERE");
 
// Get all companies
const companies = await api.getCompanies({ page: 1, pageSize: 50 });
console.log("Companies:", companies.data);
 
// Search for companies
const searchResults = await api.getCompanies({ search: "TechStartup" });
console.log("Search results:", searchResults.data);
 
// Get companies with completed analyses
const analyzed = await api.getCompletedAnalyses();
console.log("Analyzed companies:", analyzed);
 
// Get high-scoring companies
const topCompanies = await api.getCompaniesByScore(8.0);
console.log("Top companies:", topCompanies);

Result: Full-featured API client with filtering and search capabilities.

Python

Basic

CODE

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
url = "https://api.kruncher.ai/api/integration/projects"
 
headers = {
    "Authorization": f"{API_KEY}",
    "Content-Type": "application/json"
}
 
response = requests.get(url, headers=headers)
 
if response.status_code == 200:
    data = response.json()
    print(f"Found {data['pagination']['totalCount']} companies")
    print(f"Companies on this page: {len(data['data'])}")
else:
    print(f"Error: {response.status_code} {response.text}")

Result: Retrieves first page of companies.

With Pagination

CODE

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
def get_all_companies(page_size=50):
    """Fetch all companies across all pages."""
    all_companies = []
    current_page = 1
    has_more = True
 
    headers = {
        "Authorization": f"{API_KEY}",
        "Content-Type": "application/json"
    }
 
    while has_more:
        params = {
            "page": current_page,
            "pageSize": page_size
        }
        
        response = requests.get(
            f"{BASE_URL}/integration/projects",
            headers=headers,
            params=params
        )
        
        if response.status_code != 200:
            print(f"Error on page {current_page}: {response.text}")
            break
        
        result = response.json()
        all_companies.extend(result['data'])
        
        has_more = result['pagination']['nextPage']
        current_page += 1
        
        print(f"Fetched page {current_page - 1}: {len(result['data'])} companies")
 
    return all_companies
 
# Usage
companies = get_all_companies()
print(f"Total companies: {len(companies)}")

Result: Retrieves all companies with automatic pagination.

Advanced

CODE

import requests
from typing import List, Dict, Optional
from dataclasses import dataclass
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
@dataclass
class Analysis:
    id: str
    type: str
    status: str
    created_at: str
 
@dataclass
class Company:
    id: str
    name: str
    company_name: str
    website: str
    industry: str
    stage: str
    analyses: List[Analysis]
    scores: List[Dict]
 
class KruncherCompanyAPI:
    """Python client for Kruncher Company API."""
    
    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 get_companies(
        self,
        page: int = 1,
        page_size: int = 20,
        search: Optional[str] = None,
        status: Optional[str] = None
    ) -> Dict:
        """
        Get companies with optional filtering.
        
        Args:
            page: Page number (default: 1)
            page_size: Results per page (default: 20)
            search: Search term for company name
            status: Filter by status
        
        Returns:
            Dict containing data and pagination info
        """
        params = {"page": page, "pageSize": page_size}
        if search:
            params["search"] = search
        if status:
            params["status"] = status
        
        response = self.session.get(
            f"{self.base_url}/integration/projects",
            params=params
        )
        response.raise_for_status()
        return response.json()
    
    def get_all_companies(self, page_size: int = 50) -> List[Dict]:
        """Fetch all companies across all pages."""
        all_companies = []
        current_page = 1
        has_more = True
        
        while has_more:
            result = self.get_companies(page=current_page, page_size=page_size)
            all_companies.extend(result['data'])
            has_more = result['pagination']['nextPage']
            current_page += 1
        
        return all_companies
    
    def get_completed_analyses(self) -> List[Dict]:
        """Get companies with completed analyses."""
        companies = self.get_all_companies()
        return [
            company for company in companies
            if any(a.get('status') == 'completed' for a in company.get('analyses', []))
        ]
    
    def get_companies_by_score(self, min_score: float) -> List[Dict]:
        """Get companies with score >= min_score."""
        companies = self.get_all_companies()
        return [
            company for company in companies
            if any(s.get('score', 0) >= min_score for s in company.get('projectscores', []))
        ]
    
    def search_companies(self, query: str) -> List[Dict]:
        """Search companies by name."""
        result = self.get_companies(search=query, page_size=100)
        return result['data']
 
# Usage examples
api = KruncherCompanyAPI()
 
# Get first page
companies = api.get_companies(page=1, page_size=20)
print(f"Page 1: {len(companies['data'])} companies")
 
# Get all companies
all_companies = api.get_all_companies()
print(f"Total: {len(all_companies)} companies")
 
# Get companies with completed analyses
completed = api.get_completed_analyses()
print(f"Completed analyses: {len(completed)}")
 
# Search for companies
results = api.search_companies("TechStartup")
print(f"Search results: {len(results)}")
 
# Get high-scoring companies
top_companies = api.get_companies_by_score(8.0)
print(f"Top companies (score >= 8.0): {len(top_companies)}")

Result: Full-featured Python client with typing and filtering.

cURL

Basic

CODE

curl -X GET "https://api.kruncher.ai/api/integration/projects" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json"

With Pagination

CODE

curl -X GET "https://api.kruncher.ai/api/integration/projects?page=2&pageSize=50" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json"

With Search

CODE

curl -X GET "https://api.kruncher.ai/api/integration/projects?search=TechStartup" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json"

Response Structure

Success Response (200 OK)

CODE

{
  "code": "1000",
  "title": "Successful",
  "description": "",
  "data": [
    {
      "id": "proj_abc123",
      "name": "TechStartup",
      "companyName": "TechStartup Inc.",
      "companyLegalName": "TechStartup Incorporated",
      "companyEmail": "contact@techstartup.com",
      "companyWebsite": "https://techstartup.com",
      "companyIndustry": "Software",
      "companyCountry": "US",
      "companyBusinessModel": "b2b",
      "companyStage": "seriesA",
      "companyRevenueRange": "$1M-$10M",
      "isVisible": true,
      "isPending": false,
      "isUnread": false,
      "processing": "completed",
      "projectUser": {
        "role": "owner"
      },
      "analyses": [
        {
          "id": "analysis_xyz789",
          "type": "company",
          "status": "completed",
          "createdAt": "2024-01-15T10:30:00Z"
        }
      ],
      "projectscores": [
        {
          "status": "done",
          "scoreText": "Strong Fit",
          "score": 8.5
        }
      ],
      "projectstatus": {
        "name": "Active",
        "code": "active",
        "order": 1,
        "isVisible": true,
        "hasProjectPhase": true
      },
      "projectphase": {
        "name": "Due Diligence",
        "code": "dueDiligence",
        "order": 2,
        "isVisible": true
      },
      "projectowner": {
        "fullName": "John Smith",
        "email": "john@example.com",
        "status": "active"
      }
    }
  ],
  "pagination": {
    "page": 1,
    "totalCount": 150,
    "pageSize": 20,
    "nextPage": true
  }
}

Response Fields

Metadata

Field	Type	Description
`code`	string	Status code (`"1000"` for success)
`title`	string	Status message (e.g., `"Successful"`)
`description`	string	Additional context or error details

Company Data Fields

Field	Type	Description
`id`	string	Unique project identifier
`name`	string	Short project nickname
`companyName`	string	Full company name
`companyLegalName`	string	Legal entity name
`companyEmail`	string	Company contact email
`companyWebsite`	string	Company website URL
`companyIndustry`	string	Industry classification
`companyCountry`	string	Country code (ISO 3166-1)
`companyBusinessModel`	string	`b2b`, `b2c`, `b2b2c`, etc.
`companyStage`	string	`preSeed`, `seed`, `seriesA`, `seriesB`, etc.
`companyRevenueRange`	string	Revenue bracket
`isVisible`	boolean	Visibility in lists
`isPending`	boolean	Pending review status
`isUnread`	boolean	Unread notification flag
`processing`	string	Processing status
`projectUser`	object	User role information

Analysis Object

Field	Type	Description
`id`	string	Unique analysis identifier
`type`	string	Analysis type (e.g., `"company"`)
`status`	string	`completed`, `progress`, `pending`, `failed`
`createdAt`	string	ISO 8601 timestamp

Project Score Object

Field	Type	Description
`status`	string	Score calculation status
`scoreText`	string	Human-readable score description
`score`	number	Numerical score (typically 0-10)

Project Status Object

Field	Type	Description
`name`	string	Status display name
`code`	string	Status identifier
`order`	integer	Display order
`isVisible`	boolean	Visibility flag
`hasProjectPhase`	boolean	Whether project has phases

Project Phase Object

Field	Type	Description
`name`	string	Phase display name
`code`	string	Phase identifier
`order`	integer	Phase sequence number
`isVisible`	boolean	Visibility flag

Project Owner Object

Field	Type	Description
`fullName`	string	Owner’s full name
`email`	string	Owner’s email address
`status`	string	Owner account status

Pagination Object

Field	Type	Description
`page`	integer	Current page number
`totalCount`	integer	Total number of companies
`pageSize`	integer	Results per page
`nextPage`	boolean	Whether more pages exist

Common Use Cases

Filter by Analysis Status

CODE

const companies = await api.getCompanies();
const completed = companies.data.filter(company =>
  company.analyses?.some(a => a.status === 'completed')
);

Sort by Score

CODE

const companies = await api.getCompanies();
const sorted = companies.data.sort((a, b) => {
  const scoreA = a.projectscores?.[0]?.score || 0;
  const scoreB = b.projectscores?.[0]?.score || 0;
  return scoreB - scoreA;
});

Group by Industry

CODE

from collections import defaultdict
 
companies = api.get_all_companies()
by_industry = defaultdict(list)
 
for company in companies:
    industry = company.get('companyIndustry', '')
    if industry:
        by_industry[industry].append(company)
 
print(f"Software companies: {len(by_industry['Software'])}")

Error Responses

401 Unauthorized

CODE

{
  "code": "4010",
  "title": "Unauthorized",
  "description": "Invalid or missing API key"
}

500 Internal Server Error

CODE

{
  "code": "5000",
  "title": "Internal Server Error",
  "description": "An unexpected error occurred"
}

Create Company - Add new companies to your portfolio
Upload Files - Upload documents for analysis
Company Report - Access detailed analysis results
Config - Get mappings for industries, stages, etc.

Best Practices

Pagination

Use appropriate page sizes (20-50 for UI, 100 for batch processing)
Implement page caching for frequently accessed data
Handle the nextPage flag to avoid unnecessary requests

Performance

Cache company lists when appropriate
Use search parameters to reduce data transfer
Fetch all pages only when necessary

Data Handling

Always check for null or missing fields
Handle empty arrays in analyses and projectscores
Validate data types before processing

Need Help?

Large datasets? Contact support for bulk export options
Custom filtering? Let us know what filters you need
Rate limits? Check your plan for API limits

Retrieve Companies

Endpoint

Headers

Query Parameters

Code Examples

JavaScript/TypeScript

Basic

With Pagination

Advanced

Python

Basic

With Pagination

Advanced

cURL

Basic

With Pagination

With Search

Response Structure

Success Response (200 OK)

Response Fields

Metadata

Company Data Fields

Analysis Object

Project Score Object

Project Status Object

Project Phase Object

Project Owner Object

Pagination Object

Common Use Cases

Filter by Analysis Status

Sort by Score

Group by Industry

Error Responses

401 Unauthorized

500 Internal Server Error

Related Endpoints

Best Practices

Pagination

Performance

Data Handling

Need Help?