Configuration

Get all configuration values and reference data for the Kruncher.ai platform. This endpoint provides valid options for industries, countries, business models, company stages, project statuses, and other enumerated values used throughout the API.

Endpoint

GET https://api.kruncher.ai/api/config

Headers

Header	Required	Description
`Content-Type`	No	Optional `application/json`

Use Cases

When to Use Config Endpoint

Validation: Get valid options before creating or updating projects
Dropdown Menus: Populate UI dropdowns with current options
Status Mapping: Map status/phase codes to display names
ID Lookup: Find status/phase IDs for update operations
Reference Data: Access countries, industries, and other reference lists
Cache Initialization: Cache reference data at application startup

Code Examples

JavaScript/TypeScript

Basic

CODE

 
 
const response = await fetch("https://api.kruncher.ai/api/config", {
  headers: {
    "Content-Type": "application/json"
  }
});
 
const config = await response.json();
 
console.log("Project Statuses:", config.projectstatus);
console.log("Industries:", config.industries);
console.log("Countries:", config.countries);

Result: Retrieves all configuration data.

With Caching

CODE

const BASE_URL = "https://api.kruncher.ai/api";
 
class ConfigCache {
  constructor() {
    this.cache = null;
    this.lastFetch = null;
    this.ttl = 3600000; // 1 hour in ms
  }
 
  async getConfig(forceRefresh = false) {
    const now = Date.now();
    
    if (!forceRefresh && this.cache && this.lastFetch && (now - this.lastFetch < this.ttl)) {
      return this.cache;
    }
 
    const response = await fetch(`${BASE_URL}/config`, {
      headers: {
        "Content-Type": "application/json"
      }
    });
 
    if (!response.ok) {
      throw new Error(`Config fetch failed: ${response.statusText}`);
    }
 
    this.cache = await response.json();
    this.lastFetch = now;
    
    return this.cache;
  }
 
  async getStatuses() {
    const config = await this.getConfig();
    return config.projectstatus || [];
  }
 
  async getPhases() {
    const config = await this.getConfig();
    return config.projectphases || [];
  }
 
  async getIndustries() {
    const config = await this.getConfig();
    return config.industries || [];
  }
 
  async findStatusByCode(code) {
    const statuses = await this.getStatuses();
    return statuses.find(s => s.code === code);
  }
 
  async findPhaseByCode(code) {
    const phases = await this.getPhases();
    return phases.find(p => p.code === code);
  }
}
 
// Usage
const configCache = new ConfigCache();
 
// Get all config
const config = await configCache.getConfig();
console.log("Config loaded");
 
// Get specific sections
const statuses = await configCache.getStatuses();
console.log("Statuses:", statuses);
 
// Find by code
const screeningStatus = await configCache.findStatusByCode("screening");
console.log("Screening status ID:", screeningStatus?.id);

Result: Config with caching and helper methods.

Advanced

CODE

const BASE_URL = "https://api.kruncher.ai/api";
 
class KruncherConfig {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = BASE_URL;
    this.cache = null;
    this.lastFetch = null;
    this.cacheDuration = 3600000; // 1 hour
  }
 
  async fetchConfig(forceRefresh = false) {
    const now = Date.now();
    
    if (!forceRefresh && this.cache && (now - this.lastFetch < this.cacheDuration)) {
      return this.cache;
    }
 
    const response = await fetch(`${this.baseURL}/config`, {
      headers: {
        "Content-Type": "application/json"
      }
    });
 
    if (!response.ok) {
      throw new Error(`Failed to fetch config: ${response.statusText}`);
    }
 
    this.cache = await response.json();
    this.lastFetch = now;
    
    return this.cache;
  }
 
  // Status methods
  async getStatuses() {
    const config = await this.fetchConfig();
    return config.projectstatus || [];
  }
 
  async getStatusByCode(code) {
    const statuses = await this.getStatuses();
    return statuses.find(s => s.code === code) || null;
  }
 
  async getStatusById(id) {
    const statuses = await this.getStatuses();
    return statuses.find(s => s.id === id) || null;
  }
 
  // Phase methods
  async getPhases() {
    const config = await this.fetchConfig();
    return config.projectphases || [];
  }
 
  async getPhaseByCode(code) {
    const phases = await this.getPhases();
    return phases.find(p => p.code === code) || null;
  }
 
  async getPhaseById(id) {
    const phases = await this.getPhases();
    return phases.find(p => p.id === id) || null;
  }
 
  // Industry methods
  async getIndustries() {
    const config = await this.fetchConfig();
    return config.industries || [];
  }
 
  async findIndustry(search) {
    const industries = await this.getIndustries();
    return industries.find(i => 
      i.code?.toLowerCase() === search.toLowerCase() ||
      i.name?.toLowerCase() === search.toLowerCase()
    ) || null;
  }
 
  // Country methods
  async getCountries() {
    const config = await this.fetchConfig();
    return config.countries || [];
  }
 
  async getCountryByCode(code) {
    const countries = await this.getCountries();
    return countries.find(c => c.code === code) || null;
  }
 
  // Business model methods
  async getBusinessModels() {
    const config = await this.fetchConfig();
    return config.businessModels || [];
  }
 
  // Company stage methods
  async getCompanyStages() {
    const config = await this.fetchConfig();
    return config.companyStages || [];
  }
 
  async getStageByCode(code) {
    const stages = await this.getCompanyStages();
    return stages.find(s => s.code === code) || null;
  }
 
  // Revenue range methods
  async getRevenueRanges() {
    const config = await this.fetchConfig();
    return config.revenueRanges || [];
  }
 
  // Validation methods
  async isValidStatus(code) {
    const status = await this.getStatusByCode(code);
    return status !== null;
  }
 
  async isValidPhase(code) {
    const phase = await this.getPhaseByCode(code);
    return phase !== null;
  }
 
  async isValidIndustry(code) {
    const industry = await this.findIndustry(code);
    return industry !== null;
  }
 
  // UI helper methods
  async getStatusOptions() {
    const statuses = await this.getStatuses();
    return statuses.map(s => ({
      value: s.code,
      label: s.name,
      id: s.id
    }));
  }
 
  async getPhaseOptions() {
    const phases = await this.getPhases();
    return phases.map(p => ({
      value: p.code,
      label: p.name,
      id: p.id
    }));
  }
 
  async getIndustryOptions() {
    const industries = await this.getIndustries();
    return industries.map(i => ({
      value: i.code,
      label: i.name
    }));
  }
 
  // Clear cache
  clearCache() {
    this.cache = null;
    this.lastFetch = null;
  }
}
 
// Usage examples
const config = new KruncherConfig("YOUR_API_KEY_HERE");
 
// Get status by code
const screening = await config.getStatusByCode("screening");
console.log("Screening status:", screening);
 
// Get phase by code
const dueDiligence = await config.getPhaseByCode("duediligence");
console.log("Due diligence phase:", dueDiligence);
 
// Validate values
const isValid = await config.isValidStatus("active");
console.log("Is 'active' valid?", isValid);
 
// Get options for UI
const statusOptions = await config.getStatusOptions();
console.log("Status dropdown options:", statusOptions);
 
// Get industries
const industries = await config.getIndustries();
console.log("Available industries:", industries.length);
 
// Find specific industry
const saas = await config.findIndustry("SaaS");
console.log("SaaS industry:", saas);
 
// Get country info
const usa = await config.getCountryByCode("US");
console.log("USA:", usa);
 
// Force refresh cache
await config.fetchConfig(true);

Result: Full-featured config manager with caching and helpers.

Python

Basic

CODE

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
url = "https://api.kruncher.ai/api/config"
 
headers = {
    "Authorization": f"{API_KEY}",
    "Content-Type": "application/json"
}
 
response = requests.get(url, headers=headers)
 
if response.status_code == 200:
    config = response.json()
    print(f"Project Statuses: {len(config['projectstatus'])}")
    print(f"Industries: {len(config['industries'])}")
    print(f"Countries: {len(config['countries'])}")
else:
    print(f"Error: {response.status_code} {response.text}")

Result: Retrieves all configuration data.

With Caching

CODE

import requests
import time
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
class ConfigCache:
    """Simple config cache with TTL."""
    
    def __init__(self, ttl_seconds=3600):
        self.cache = None
        self.last_fetch = None
        self.ttl = ttl_seconds
    
    def get_config(self, force_refresh=False):
        """Get config from cache or fetch if expired."""
        now = time.time()
        
        if not force_refresh and self.cache and self.last_fetch:
            if (now - self.last_fetch) < self.ttl:
                return self.cache
        
        headers = {
            "Authorization": f"{API_KEY}",
            "Content-Type": "application/json"
        }
        
        response = requests.get(f"{BASE_URL}/config", headers=headers)
        response.raise_for_status()
        
        self.cache = response.json()
        self.last_fetch = now
        
        return self.cache
    
    def get_statuses(self):
        config = self.get_config()
        return config.get('projectstatus', [])
    
    def get_phases(self):
        config = self.get_config()
        return config.get('projectphases', [])
    
    def find_status_by_code(self, code):
        statuses = self.get_statuses()
        return next((s for s in statuses if s.get('code') == code), None)
    
    def find_phase_by_code(self, code):
        phases = self.get_phases()
        return next((p for p in phases if p.get('code') == code), None)
 
# Usage
cache = ConfigCache()
 
# Get config
config = cache.get_config()
print(f"Config loaded: {len(config)} sections")
 
# Get statuses
statuses = cache.get_statuses()
print(f"Available statuses: {len(statuses)}")
 
# Find by code
screening = cache.find_status_by_code("screening")
print(f"Screening status ID: {screening['id']}")

Result: Config with simple caching mechanism.

Advanced

CODE

import requests
import time
from typing import Dict, List, Optional
from dataclasses import dataclass
from functools import lru_cache
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
@dataclass
class Status:
    id: str
    code: str
    name: str
    order: int
    is_visible: bool
 
@dataclass
class Phase:
    id: str
    code: str
    name: str
    order: int
    is_visible: bool
 
class KruncherConfig:
    """Comprehensive Kruncher configuration manager."""
    
    def __init__(self, api_key: str = API_KEY, cache_ttl: int = 3600):
        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"
        })
        self.cache = None
        self.last_fetch = None
        self.cache_ttl = cache_ttl
    
    def fetch_config(self, force_refresh: bool = False) -> Dict:
        """
        Fetch configuration from API with caching.
        
        Args:
            force_refresh: Force refresh even if cache is valid
        
        Returns:
            Configuration dictionary
        """
        now = time.time()
        
        if not force_refresh and self.cache and self.last_fetch:
            if (now - self.last_fetch) < self.cache_ttl:
                return self.cache
        
        response = self.session.get(f"{self.base_url}/config")
        response.raise_for_status()
        
        self.cache = response.json()
        self.last_fetch = now
        
        return self.cache
    
    # Status methods
    def get_statuses(self) -> List[Dict]:
        """Get all project statuses."""
        config = self.fetch_config()
        return config.get('projectstatus', [])
    
    def get_status_by_code(self, code: str) -> Optional[Dict]:
        """Find status by code."""
        statuses = self.get_statuses()
        return next((s for s in statuses if s.get('code') == code), None)
    
    def get_status_by_id(self, status_id: str) -> Optional[Dict]:
        """Find status by ID."""
        statuses = self.get_statuses()
        return next((s for s in statuses if s.get('id') == status_id), None)
    
    # Phase methods
    def get_phases(self) -> List[Dict]:
        """Get all project phases."""
        config = self.fetch_config()
        return config.get('projectphases', [])
    
    def get_phase_by_code(self, code: str) -> Optional[Dict]:
        """Find phase by code."""
        phases = self.get_phases()
        return next((p for p in phases if p.get('code') == code), None)
    
    def get_phase_by_id(self, phase_id: str) -> Optional[Dict]:
        """Find phase by ID."""
        phases = self.get_phases()
        return next((p for p in phases if p.get('id') == phase_id), None)
    
    # Industry methods
    def get_industries(self) -> List[Dict]:
        """Get all industries."""
        config = self.fetch_config()
        return config.get('industries', [])
    
    def find_industry(self, search: str) -> Optional[Dict]:
        """Find industry by code or name."""
        industries = self.get_industries()
        search_lower = search.lower()
        return next(
            (i for i in industries 
             if i.get('code', '').lower() == search_lower 
             or i.get('name', '').lower() == search_lower),
            None
        )
    
    # Country methods
    def get_countries(self) -> List[Dict]:
        """Get all countries."""
        config = self.fetch_config()
        return config.get('countries', [])
    
    def get_country_by_code(self, code: str) -> Optional[Dict]:
        """Find country by ISO code."""
        countries = self.get_countries()
        return next((c for c in countries if c.get('code') == code), None)
    
    # Business model methods
    def get_business_models(self) -> List[Dict]:
        """Get all business models."""
        config = self.fetch_config()
        return config.get('businessModels', [])
    
    # Company stage methods
    def get_company_stages(self) -> List[Dict]:
        """Get all company stages."""
        config = self.fetch_config()
        return config.get('companyStages', [])
    
    def get_stage_by_code(self, code: str) -> Optional[Dict]:
        """Find company stage by code."""
        stages = self.get_company_stages()
        return next((s for s in stages if s.get('code') == code), None)
    
    # Revenue range methods
    def get_revenue_ranges(self) -> List[Dict]:
        """Get all revenue ranges."""
        config = self.fetch_config()
        return config.get('revenueRanges', [])
    
    # Validation methods
    def is_valid_status(self, code: str) -> bool:
        """Check if status code is valid."""
        return self.get_status_by_code(code) is not None
    
    def is_valid_phase(self, code: str) -> bool:
        """Check if phase code is valid."""
        return self.get_phase_by_code(code) is not None
    
    def is_valid_industry(self, code: str) -> bool:
        """Check if industry code is valid."""
        return self.find_industry(code) is not None
    
    def is_valid_country(self, code: str) -> bool:
        """Check if country code is valid."""
        return self.get_country_by_code(code) is not None
    
    # UI helper methods
    def get_status_options(self) -> List[Dict[str, str]]:
        """Get status options for UI dropdowns."""
        statuses = self.get_statuses()
        return [
            {
                'value': s.get('code'),
                'label': s.get('name'),
                'id': s.get('id')
            }
            for s in statuses
        ]
    
    def get_phase_options(self) -> List[Dict[str, str]]:
        """Get phase options for UI dropdowns."""
        phases = self.get_phases()
        return [
            {
                'value': p.get('code'),
                'label': p.get('name'),
                'id': p.get('id')
            }
            for p in phases
        ]
    
    def get_industry_options(self) -> List[Dict[str, str]]:
        """Get industry options for UI dropdowns."""
        industries = self.get_industries()
        return [
            {
                'value': i.get('code'),
                'label': i.get('name')
            }
            for i in industries
        ]
    
    def get_country_options(self) -> List[Dict[str, str]]:
        """Get country options for UI dropdowns."""
        countries = self.get_countries()
        return [
            {
                'value': c.get('code'),
                'label': c.get('name')
            }
            for c in countries
        ]
    
    # Summary methods
    def get_summary(self) -> Dict:
        """Get summary of all config sections."""
        config = self.fetch_config()
        return {
            'statuses': len(config.get('projectstatus', [])),
            'phases': len(config.get('projectphases', [])),
            'industries': len(config.get('industries', [])),
            'countries': len(config.get('countries', [])),
            'businessModels': len(config.get('businessModels', [])),
            'companyStages': len(config.get('companyStages', [])),
            'revenueRanges': len(config.get('revenueRanges', []))
        }
    
    def clear_cache(self):
        """Clear configuration cache."""
        self.cache = None
        self.last_fetch = None
 
# Usage examples
config = KruncherConfig()
 
# Get status by code
screening = config.get_status_by_code("screening")
print(f"Screening status: {screening}")
 
# Get phase by code
due_diligence = config.get_phase_by_code("duediligence")
print(f"Due diligence: {due_diligence}")
 
# Validate values
print(f"Is 'active' valid? {config.is_valid_status('active')}")
print(f"Is 'SaaS' valid? {config.is_valid_industry('SaaS')}")
 
# Get UI options
status_options = config.get_status_options()
print(f"Status options: {len(status_options)}")
 
# Get summary
summary = config.get_summary()
print(f"Config summary: {summary}")
 
# Find industry
saas = config.find_industry("SaaS")
print(f"SaaS industry: {saas}")
 
# Get country
usa = config.get_country_by_code("US")
print(f"USA: {usa}")
 
# Get all industries
industries = config.get_industries()
print(f"Total industries: {len(industries)}")
for industry in industries[:5]:
    print(f"  - {industry.get('name')} ({industry.get('code')})")

Result: Production-ready config manager with comprehensive helpers.

cURL

Basic

CODE

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

With jq

CODE

# Get all status codes
curl -s -X GET "https://api.kruncher.ai/api/config" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '.projectstatus[] | {code: .code, name: .name, id: .id}'
 
# Find screening status ID
curl -s -X GET "https://api.kruncher.ai/api/config" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '.projectstatus[] | select(.code == "screening") | .id'
 
# Get all industries
curl -s -X GET "https://api.kruncher.ai/api/config" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '.industries[] | {code: .code, name: .name}'

Pretty Print

CODE

# Pretty print config
curl -s -X GET "https://api.kruncher.ai/api/config" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '.'
 
# Save to file
curl -s -X GET "https://api.kruncher.ai/api/config" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '.' > kruncher-config.json
 
echo "Config saved to kruncher-config.json"

Response Structure

Success Response (200 OK)

CODE

{
  "code": "1000",
  "title": "Success",
  "projectstatus": [
    {
      "id": "status_001",
      "code": "active",
      "name": "Active",
      "order": 1,
      "isVisible": true
    },
    {
      "id": "status_002",
      "code": "screening",
      "name": "Screening",
      "order": 2,
      "isVisible": true
    },
    {
      "id": "status_003",
      "code": "dropped",
      "name": "Dropped",
      "order": 3,
      "isVisible": true
    }
  ],
  "projectphases": [
    {
      "id": "phase_001",
      "code": "undecided",
      "name": "Undecided",
      "order": 1,
      "isVisible": true
    },
    {
      "id": "phase_002",
      "code": "duediligence",
      "name": "Due Diligence",
      "order": 2,
      "isVisible": true
    },
    {
      "id": "phase_003",
      "code": "invested",
      "name": "Invested",
      "order": 3,
      "isVisible": true
    },
    {
      "id": "phase_004",
      "code": "rejected",
      "name": "Rejected",
      "order": 4,
      "isVisible": true
    }
  ],
  "industries": [
    {
      "code": "saas",
      "name": "SaaS"
    },
    {
      "code": "fintech",
      "name": "FinTech"
    },
    {
      "code": "healthtech",
      "name": "HealthTech"
    },
    {
      "code": "ecommerce",
      "name": "E-commerce"
    }
  ],
  "countries": [
    {
      "code": "US",
      "name": "United States"
    },
    {
      "code": "UK",
      "name": "United Kingdom"
    },
    {
      "code": "CA",
      "name": "Canada"
    }
  ],
  "businessModels": [
    {
      "code": "b2b",
      "name": "B2B"
    },
    {
      "code": "b2c",
      "name": "B2C"
    },
    {
      "code": "b2b2c",
      "name": "B2B2C"
    },
    {
      "code": "marketplace",
      "name": "Marketplace"
    }
  ],
  "companyStages": [
    {
      "code": "preSeed",
      "name": "Pre-Seed"
    },
    {
      "code": "seed",
      "name": "Seed"
    },
    {
      "code": "seriesA",
      "name": "Series A"
    },
    {
      "code": "seriesB",
      "name": "Series B"
    }
  ],
  "revenueRanges": [
    {
      "code": "0-100k",
      "name": "$0 - $100K"
    },
    {
      "code": "100k-1m",
      "name": "$100K - $1M"
    },
    {
      "code": "1m-10m",
      "name": "$1M - $10M"
    }
  ]
}

Configuration Sections

Project Status

Status values for project workflow:

Code	Name	Typical Use
`active`	Active	Currently evaluating
`screening`	Screening	Initial review phase
`dropped`	Dropped	No longer pursuing
`onhold`	On Hold	Paused evaluation
`archived`	Archived	Historical record

Project Phases

Investment decision phases:

Code	Name	Description
`undecided`	Undecided	Not yet decided
`duediligence`	Due Diligence	Active investigation
`invested`	Invested	Investment made
`rejected`	Rejected	Passed on opportunity
`exited`	Exited	Investment realized

Industries

Common industry classifications available in the platform.

Countries

ISO country codes with display names for all supported countries.

Business Models

Code	Name
`b2b`	B2B
`b2c`	B2C
`b2b2c`	B2B2C
`marketplace`	Marketplace

Company Stages

Code	Name
`preSeed`	Pre-Seed
`seed`	Seed
`seriesA`	Series A
`seriesB`	Series B
`seriesC`	Series C
`growth`	Growth
`ipo`	IPO

Revenue Ranges

Pre-defined revenue brackets for categorization.

Common Use Cases

Validate Before Create

CODE

const config = new KruncherConfig(API_KEY);
 
// Validate industry before creating company
const industry = "SaaS";
if (await config.isValidIndustry(industry)) {
  // Create company with validated industry
  await createCompany({ industry });
} else {
  console.error(`Invalid industry: ${industry}`);
}

Populate UI Dropdowns

CODE

config = KruncherConfig()
 
# Get options for form dropdowns
status_options = config.get_status_options()
phase_options = config.get_phase_options()
industry_options = config.get_industry_options()
 
# Use in UI framework
render_dropdown("status", status_options)
render_dropdown("phase", phase_options)
render_dropdown("industry", industry_options)

Find IDs for Updates

CODE

// Find status and phase IDs for update operation
const config = new KruncherConfig(API_KEY);
 
const screeningStatus = await config.getStatusByCode("screening");
const dueDiligencePhase = await config.getPhaseByCode("duediligence");
 
// Use IDs in update request
await updateProject(projectId, {
  statusId: screeningStatus.id,
  phaseId: dueDiligencePhase.id
});

Map Codes to Names

CODE

# Display friendly names from codes
config = KruncherConfig()
 
status_code = "screening"
status = config.get_status_by_code(status_code)
print(f"Status: {status['name']}")  # "Screening"
 
phase_code = "duediligence"
phase = config.get_phase_by_code(phase_code)
print(f"Phase: {phase['name']}")  # "Due Diligence"

Best Practices

Cache Configuration

Config data changes infrequently
Cache for 1 hour minimum
Refresh cache on application startup
Use force refresh only when needed

Validation

Always validate codes before API calls
Check existence before using IDs
Provide helpful error messages
Fall back to default values when appropriate

Performance

Fetch config once at startup
Share config instance across application
Don’t fetch on every request
Use in-memory cache for lookups

Error Handling

Handle network failures gracefully
Provide fallback values
Log cache misses
Retry failed fetches

Integration Examples

React Hook

CODE

import { useState, useEffect } from 'react';
 
function useKruncherConfig() {
  const [config, setConfig] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
 
  useEffect(() => {
    const configManager = new KruncherConfig(API_KEY);
    
    configManager.fetchConfig()
      .then(data => {
        setConfig(configManager);
        setLoading(false);
      })
      .catch(err => {
        setError(err);
        setLoading(false);
      });
  }, []);
 
  return { config, loading, error };
}
 
// Usage in component
function MyComponent() {
  const { config, loading } = useKruncherConfig();
 
  if (loading) return <div>Loading...</div>;
 
  const statuses = config.getStatuses();
  
  return (
    <select>
      {statuses.map(s => (
        <option key={s.id} value={s.code}>{s.name}</option>
      ))}
    </select>
  );
}

Django Cache

CODE

from django.core.cache import cache
from datetime import timedelta
 
def get_kruncher_config():
    """Get config with Django cache."""
    config_data = cache.get('kruncher_config')
    
    if not config_data:
        config_manager = KruncherConfig()
        config_data = config_manager.fetch_config()
        cache.set('kruncher_config', config_data, timeout=3600)
    
    return config_data
 
# Usage in view
def company_form(request):
    config = get_kruncher_config()
    industries = config.get('industries', [])
    
    return render(request, 'form.html', {
        'industries': industries
    })

Create Company - Use config to validate inputs
Update Criteria - Get valid criteria codes
Find Companies - Understand status/phase values
Update Analysis - Validate entity values

Troubleshooting

Config Not Loading

Check API key is valid
Verify network connectivity
Check for CORS issues in browser
Review error response

Missing Sections

Different accounts may have different config sections
Check response structure
Use .get() with defaults
Contact support for custom config

Outdated Cache

Force refresh if values seem stale
Check cache TTL settings
Clear cache manually if needed
Consider shorter cache duration

Need Help?

Custom options? Contact support to add industries, statuses, etc.
Missing data? Check your account configuration
Integration issues? Review the code examples above

Configuration

Endpoint

Headers

Use Cases

When to Use Config Endpoint

Code Examples

JavaScript/TypeScript

Basic

With Caching

Advanced

Python

Basic

With Caching

Advanced

cURL

Basic

With jq

Pretty Print

Response Structure

Success Response (200 OK)

Configuration Sections

Project Status

Project Phases

Industries

Countries

Business Models

Company Stages

Revenue Ranges

Common Use Cases

Validate Before Create

Populate UI Dropdowns

Find IDs for Updates

Map Codes to Names

Best Practices

Cache Configuration

Validation

Performance

Error Handling

Integration Examples

React Hook

Django Cache

Related Endpoints

Troubleshooting

Config Not Loading

Missing Sections

Outdated Cache

Need Help?