Change Criteria

Set or update the scoring criteria values for a company report. This endpoint allows you to assign specific criteria selections that affect the company report’s scoring and analysis results.

Endpoint

POST https://api.kruncher.ai/api/integration/project/criteria

Headers

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

Request Body

Field	Type	Required	Description
`projectId`	string (UUID)	Yes	The unique identifier for the project
`projectscoreId`	string (UUID)	Yes	The unique identifier for the project’s score
`postanalysisoutputId`	string (UUID)	Yes	The unique identifier for the post-analysis output
`criteriaSelectedCode`	string	Yes	Code representing the selected criteria (e.g., `advertisingandmarketing`)
`criteriaSelectedName`	string	Yes	Display name of the selected criteria (e.g., `Advertising & Marketing`)

Use Cases

Adjust Scoring Criteria: Change how projects are scored based on investment focus
Update Investment Thesis: Reflect changes in investment strategy and priorities
Multi-factor Analysis: Set different criteria for different project types
Risk Assessment: Adjust criteria to focus on specific risk factors
Portfolio Alignment: Update criteria to match portfolio company profiles

Quick Start

cURL

CODE

curl -X POST "https://api.kruncher.ai/api/integration/project/criteria" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "projectscoreId": "7c904e6a-e797-4b5b-8c28-feaf34b5ac75",
    "postanalysisoutputId": "8756d0e9-8398-47ba-8d0e-f88ab53c38f3",
    "criteriaSelectedCode": "advertisingandmarketing",
    "criteriaSelectedName": "Advertising & Marketing"
  }'

Response:

CODE

{
  "success": true,
  "data": {
    "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "criteriaCode": "advertisingandmarketing",
    "criteriaName": "Advertising & Marketing",
    "updatedAt": "2024-01-15T10:30:00Z",
    "scoreUpdated": true
  }
}

Code Examples

JavaScript/TypeScript

Basic

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
async function setProjectCriteria(
  projectId,
  projectscoreId,
  postanalysisoutputId,
  criteriaCode,
  criteriaName
) {
  const response = await fetch(`${BASE_URL}/integration/project/criteria`, {
    method: "POST",
    headers: {
      "Authorization": `${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      projectId,
      projectscoreId,
      postanalysisoutputId,
      criteriaSelectedCode: criteriaCode,
      criteriaSelectedName: criteriaName
    })
  });
 
  if (!response.ok) {
    throw new Error(`Failed to set criteria: ${response.statusText}`);
  }
 
  return await response.json();
}
 
// Usage
const result = await setProjectCriteria(
  "521a93a6-091d-4943-ba13-7c1a654a14ae",
  "7c904e6a-e797-4b5b-8c28-feaf34b5ac75",
  "8756d0e9-8398-47ba-8d0e-f88ab53c38f3",
  "advertisingandmarketing",
  "Advertising & Marketing"
);
 
console.log("Criteria updated:", result.data.criteriaName);

Result: Basic criteria update.

With Error Handling

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
async function setProjectCriteria(
  projectId,
  projectscoreId,
  postanalysisoutputId,
  criteriaCode,
  criteriaName
) {
  // Validate UUIDs
  const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
  
  if (!uuidPattern.test(projectId)) {
    throw new Error("Invalid projectId format");
  }
  if (!uuidPattern.test(projectscoreId)) {
    throw new Error("Invalid projectscoreId format");
  }
  if (!uuidPattern.test(postanalysisoutputId)) {
    throw new Error("Invalid postanalysisoutputId format");
  }
 
  // Validate criteria
  if (!criteriaCode || !criteriaName) {
    throw new Error("Criteria code and name are required");
  }
 
  const response = await fetch(`${BASE_URL}/integration/project/criteria`, {
    method: "POST",
    headers: {
      "Authorization": `${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      projectId,
      projectscoreId,
      postanalysisoutputId,
      criteriaSelectedCode: criteriaCode,
      criteriaSelectedName: criteriaName
    })
  });
 
  if (response.status === 404) {
    throw new Error("Project, score, or analysis output not found");
  }
 
  if (response.status === 400) {
    const error = await response.json();
    throw new Error(`Invalid request: ${error.message}`);
  }
 
  if (!response.ok) {
    throw new Error(`Failed to set criteria: ${response.statusText}`);
  }
 
  return await response.json();
}
 
// Usage with error handling
try {
  const result = await setProjectCriteria(
    "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "7c904e6a-e797-4b5b-8c28-feaf34b5ac75",
    "8756d0e9-8398-47ba-8d0e-f88ab53c38f3",
    "advertisingandmarketing",
    "Advertising & Marketing"
  );
  
  console.log("✓ Criteria updated:", result.data.criteriaName);
  console.log("  Score updated:", result.data.scoreUpdated);
  console.log("  Updated at:", result.data.updatedAt);
} catch (error) {
  console.error("✗ Error:", error.message);
}

Result: Production-ready with validation and error handling.

Batch Update

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
async function setProjectCriteria(
  projectId,
  projectscoreId,
  postanalysisoutputId,
  criteriaCode,
  criteriaName
) {
  const response = await fetch(`${BASE_URL}/integration/project/criteria`, {
    method: "POST",
    headers: {
      "Authorization": `${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      projectId,
      projectscoreId,
      postanalysisoutputId,
      criteriaSelectedCode: criteriaCode,
      criteriaSelectedName: criteriaName
    })
  });
 
  if (!response.ok) {
    throw new Error(`Failed to set criteria: ${response.statusText}`);
  }
 
  return await response.json();
}
 
async function updateProjectsCriteriaBatch(projects) {
  /**
   * projects: Array of objects with:
   * - projectId, projectscoreId, postanalysisoutputId
   * - criteriaCode, criteriaName
   */
 
  const results = {
    successful: [],
    failed: [],
    skipped: [],
    stats: {
      total: projects.length,
      successCount: 0,
      failureCount: 0,
      updatedAt: new Date().toISOString()
    }
  };
 
  for (const project of projects) {
    try {
      // Skip if missing required fields
      if (!project.projectId || !project.criteriaCode) {
        results.skipped.push({
          projectId: project.projectId,
          reason: "Missing required fields"
        });
        continue;
      }
 
      const result = await setProjectCriteria(
        project.projectId,
        project.projectscoreId,
        project.postanalysisoutputId,
        project.criteriaCode,
        project.criteriaName
      );
 
      results.successful.push({
        projectId: project.projectId,
        criteria: project.criteriaName,
        updatedAt: result.data.updatedAt
      });
 
      results.stats.successCount++;
      console.log(`✓ Updated ${project.projectId}: ${project.criteriaName}`);
    } catch (error) {
      results.failed.push({
        projectId: project.projectId,
        criteriaCode: project.criteriaCode,
        error: error.message
      });
 
      results.stats.failureCount++;
      console.error(`✗ Failed ${project.projectId}: ${error.message}`);
    }
  }
 
  return results;
}
 
// Usage - batch update
const projectsToUpdate = [
  {
    projectId: "521a93a6-091d-4943-ba13-7c1a654a14ae",
    projectscoreId: "7c904e6a-e797-4b5b-8c28-feaf34b5ac75",
    postanalysisoutputId: "8756d0e9-8398-47ba-8d0e-f88ab53c38f3",
    criteriaCode: "advertisingandmarketing",
    criteriaName: "Advertising & Marketing"
  },
  {
    projectId: "631b84b7-192e-5a65-db35-9e876c836cb6",
    projectscoreId: "8d915f7b-f808-5c6c-9d39-gfbg45c6bd86",
    postanalysisoutputId: "9867e1fa-9499-58cb-9e1f-g99bc64c39d4",
    criteriaCode: "softwareandtech",
    criteriaName: "Software & Technology"
  }
];
 
const results = await updateProjectsCriteriaBatch(projectsToUpdate);
 
console.log("\nBatch Summary:");
console.log(`✓ Successful: ${results.stats.successCount}`);
console.log(`✗ Failed: ${results.stats.failureCount}`);
console.log(`⊘ Skipped: ${results.skipped.length}`);

Result: Batch update with error tracking and statistics.

Auto-lookup

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
class CriteriaManager {
  constructor(apiKey = API_KEY) {
    this.apiKey = apiKey;
    this.baseUrl = BASE_URL;
  }
 
  async setProjectCriteria(
    projectId,
    projectscoreId,
    postanalysisoutputId,
    criteriaCode,
    criteriaName
  ) {
    const response = await fetch(`${this.baseUrl}/integration/project/criteria`, {
      method: "POST",
      headers: {
        "Authorization": `${this.apiKey}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        projectId,
        projectscoreId,
        postanalysisoutputId,
        criteriaSelectedCode: criteriaCode,
        criteriaSelectedName: criteriaName
      })
    });
 
    if (!response.ok) {
      throw new Error(`Failed to set criteria: ${response.statusText}`);
    }
 
    return await response.json();
  }
 
  /**
   * Automatically look up IDs from project and update criteria
   * Requires helper function to fetch project details
   */
  async updateCriteriaWithLookup(
    projectId,
    criteriaCode,
    criteriaName,
    projectDetailsLookup
  ) {
    try {
      // Look up project details to get required IDs
      const projectDetails = await projectDetailsLookup(projectId);
 
      if (!projectDetails.projectscoreId || !projectDetails.postanalysisoutputId) {
        throw new Error("Could not find required IDs for project");
      }
 
      // Update criteria
      const result = await this.setProjectCriteria(
        projectId,
        projectDetails.projectscoreId,
        projectDetails.postanalysisoutputId,
        criteriaCode,
        criteriaName
      );
 
      return {
        success: true,
        data: result.data,
        lookupPerformed: true
      };
    } catch (error) {
      return {
        success: false,
        error: error.message,
        projectId
      };
    }
  }
}
 
// Usage with auto-lookup (if you have a project details function)
const manager = new CriteriaManager();
 
// Simple approach - you need to provide the lookup function
async function getProjectDetails(projectId) {
  // This would fetch from your system
  const response = await fetch(`${BASE_URL}/integration/project/${projectId}`);
  return await response.json();
}
 
// Update with automatic ID lookup
const result = await manager.updateCriteriaWithLookup(
  "521a93a6-091d-4943-ba13-7c1a654a14ae",
  "advertisingandmarketing",
  "Advertising & Marketing",
  getProjectDetails
);
 
if (result.success) {
  console.log("✓ Criteria updated:", result.data.criteriaName);
} else {
  console.error("✗ Error:", result.error);
}

Result: Manager class with optional auto-lookup of IDs.

Python

Basic

CODE

import requests
from typing import Dict
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
def set_project_criteria(
    project_id: str,
    projectscore_id: str,
    postanalysisoutput_id: str,
    criteria_code: str,
    criteria_name: str
) -> Dict:
    """Set criteria for a project."""
    url = f"{BASE_URL}/integration/project/criteria"
    
    headers = {
        "Authorization": f"{API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "projectId": project_id,
        "projectscoreId": projectscore_id,
        "postanalysisoutputId": postanalysisoutput_id,
        "criteriaSelectedCode": criteria_code,
        "criteriaSelectedName": criteria_name
    }
    
    response = requests.post(url, json=payload, headers=headers)
    response.raise_for_status()
    
    return response.json()
 
# Usage
result = set_project_criteria(
    "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "7c904e6a-e797-4b5b-8c28-feaf34b5ac75",
    "8756d0e9-8398-47ba-8d0e-f88ab53c38f3",
    "advertisingandmarketing",
    "Advertising & Marketing"
)
 
print(f"Criteria updated: {result['data']['criteriaName']}")

Result: Basic criteria update.

With Error Handling

CODE

import requests
import re
from typing import Dict, Optional
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
def set_project_criteria(
    project_id: str,
    projectscore_id: str,
    postanalysisoutput_id: str,
    criteria_code: str,
    criteria_name: str
) -> Dict:
    """Set criteria for a project with validation."""
    
    # Validate UUIDs
    uuid_pattern = r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
    
    for uuid_val, name in [
        (project_id, "projectId"),
        (projectscore_id, "projectscoreId"),
        (postanalysisoutput_id, "postanalysisoutputId")
    ]:
        if not re.match(uuid_pattern, uuid_val, re.IGNORECASE):
            raise ValueError(f"Invalid {name} format: {uuid_val}")
    
    # Validate criteria
    if not criteria_code or not criteria_name:
        raise ValueError("Criteria code and name are required")
    
    url = f"{BASE_URL}/integration/project/criteria"
    
    headers = {
        "Authorization": f"{API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "projectId": project_id,
        "projectscoreId": projectscore_id,
        "postanalysisoutputId": postanalysisoutput_id,
        "criteriaSelectedCode": criteria_code,
        "criteriaSelectedName": criteria_name
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers)
        
        if response.status_code == 404:
            raise ValueError("Project, score, or analysis output not found")
        
        if response.status_code == 400:
            error_data = response.json()
            raise ValueError(f"Invalid request: {error_data.get('message')}")
        
        response.raise_for_status()
        return response.json()
    
    except requests.exceptions.RequestException as e:
        raise Exception(f"Failed to set criteria: {str(e)}")
 
# Usage with error handling
try:
    result = set_project_criteria(
        "521a93a6-091d-4943-ba13-7c1a654a14ae",
        "7c904e6a-e797-4b5b-8c28-feaf34b5ac75",
        "8756d0e9-8398-47ba-8d0e-f88ab53c38f3",
        "advertisingandmarketing",
        "Advertising & Marketing"
    )
    
    print(f"✓ Criteria updated: {result['data']['criteriaName']}")
    print(f"  Score updated: {result['data']['scoreUpdated']}")
    print(f"  Updated at: {result['data']['updatedAt']}")
except ValueError as e:
    print(f"✗ Validation error: {e}")
except Exception as e:
    print(f"✗ Error: {e}")

Result: Production-ready with validation.

Batch Update

CODE

import requests
from typing import List, Dict
from datetime import datetime
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
class CriteriaManager:
    """Manage criteria updates for multiple projects."""
    
    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 set_criteria(
        self,
        project_id: str,
        projectscore_id: str,
        postanalysisoutput_id: str,
        criteria_code: str,
        criteria_name: str
    ) -> Dict:
        """Set criteria for a single project."""
        url = f"{self.base_url}/integration/project/criteria"
        
        payload = {
            "projectId": project_id,
            "projectscoreId": projectscore_id,
            "postanalysisoutputId": postanalysisoutput_id,
            "criteriaSelectedCode": criteria_code,
            "criteriaSelectedName": criteria_name
        }
        
        response = self.session.post(url, json=payload)
        
        if response.status_code == 404:
            raise ValueError(f"Project not found: {project_id}")
        
        if response.status_code == 400:
            raise ValueError(f"Invalid request: {response.json().get('message')}")
        
        response.raise_for_status()
        return response.json()
    
    def update_criteria_batch(self, projects: List[Dict]) -> Dict:
        """
        Update criteria for multiple projects.
        
        Args:
            projects: List of dicts with projectId, projectscoreId, 
                     postanalysisoutputId, criteriaCode, criteriaName
        
        Returns:
            Dictionary with 'successful', 'failed', and 'stats'
        """
        results = {
            'successful': [],
            'failed': [],
            'skipped': [],
            'stats': {
                'total': len(projects),
                'success': 0,
                'failure': 0,
                'skipped': 0,
                'timestamp': datetime.now().isoformat()
            }
        }
        
        for project in projects:
            try:
                # Validate required fields
                required_fields = [
                    'projectId', 'projectscoreId', 'postanalysisoutputId',
                    'criteriaCode', 'criteriaName'
                ]
                
                if not all(project.get(field) for field in required_fields):
                    results['skipped'].append({
                        'projectId': project.get('projectId'),
                        'reason': 'Missing required fields'
                    })
                    results['stats']['skipped'] += 1
                    continue
                
                # Update criteria
                result = self.set_criteria(
                    project['projectId'],
                    project['projectscoreId'],
                    project['postanalysisoutputId'],
                    project['criteriaCode'],
                    project['criteriaName']
                )
                
                results['successful'].append({
                    'projectId': project['projectId'],
                    'criteria': project['criteriaName'],
                    'updatedAt': result['data']['updatedAt']
                })
                
                results['stats']['success'] += 1
                print(f"✓ Updated {project['projectId']}: {project['criteriaName']}")
            
            except Exception as e:
                results['failed'].append({
                    'projectId': project.get('projectId'),
                    'criteria': project.get('criteriaCode'),
                    'error': str(e)
                })
                
                results['stats']['failure'] += 1
                print(f"✗ Failed {project['projectId']}: {e}")
        
        return results
    
    def print_summary(self, results: Dict) -> None:
        """Print batch operation summary."""
        stats = results['stats']
        
        print("\n" + "="*50)
        print("Criteria Update Summary")
        print("="*50)
        print(f"Total projects: {stats['total']}")
        print(f"✓ Successful: {stats['success']}")
        print(f"✗ Failed: {stats['failure']}")
        print(f"⊘ Skipped: {stats['skipped']}")
        
        if results['failed']:
            print("\nFailed projects:")
            for item in results['failed']:
                print(f"  - {item['projectId']}: {item['error']}")
 
# Usage
manager = CriteriaManager()
 
projects_to_update = [
    {
        'projectId': '521a93a6-091d-4943-ba13-7c1a654a14ae',
        'projectscoreId': '7c904e6a-e797-4b5b-8c28-feaf34b5ac75',
        'postanalysisoutputId': '8756d0e9-8398-47ba-8d0e-f88ab53c38f3',
        'criteriaCode': 'advertisingandmarketing',
        'criteriaName': 'Advertising & Marketing'
    },
    {
        'projectId': '631b84b7-192e-5a65-db35-9e876c836cb6',
        'projectscoreId': '8d915f7b-f808-5c6c-9d39-gfbg45c6bd86',
        'postanalysisoutputId': '9867e1fa-9499-58cb-9e1f-g99bc64c39d4',
        'criteriaCode': 'softwareandtech',
        'criteriaName': 'Software & Technology'
    }
]
 
results = manager.update_criteria_batch(projects_to_update)
manager.print_summary(results)

Result: Production-ready batch manager with reporting.

Auto-lookup

CODE

import requests
from typing import Optional, Dict, Callable
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
class CriteriaManager:
    """Manage criteria updates with auto-lookup capability."""
    
    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 set_criteria(
        self,
        project_id: str,
        projectscore_id: str,
        postanalysisoutput_id: str,
        criteria_code: str,
        criteria_name: str
    ) -> Dict:
        """Set criteria for a project."""
        url = f"{self.base_url}/integration/project/criteria"
        
        payload = {
            "projectId": project_id,
            "projectscoreId": projectscore_id,
            "postanalysisoutputId": postanalysisoutput_id,
            "criteriaSelectedCode": criteria_code,
            "criteriaSelectedName": criteria_name
        }
        
        response = self.session.post(url, json=payload)
        response.raise_for_status()
        return response.json()
    
    def update_with_lookup(
        self,
        project_id: str,
        criteria_code: str,
        criteria_name: str,
        lookup_func: Callable
    ) -> Dict:
        """
        Update criteria with automatic ID lookup.
        
        Args:
            project_id: The project ID
            criteria_code: Criteria code
            criteria_name: Criteria name
            lookup_func: Function that fetches project details and returns
                        dict with 'projectscoreId' and 'postanalysisoutputId'
        
        Returns:
            Success dict with updated criteria
        """
        try:
            # Look up project details
            project_details = lookup_func(project_id)
            
            if not project_details.get('projectscoreId'):
                raise ValueError("Could not find projectscoreId")
            
            if not project_details.get('postanalysisoutputId'):
                raise ValueError("Could not find postanalysisoutputId")
            
            # Update criteria
            result = self.set_criteria(
                project_id,
                project_details['projectscoreId'],
                project_details['postanalysisoutputId'],
                criteria_code,
                criteria_name
            )
            
            return {
                'success': True,
                'data': result['data'],
                'lookup_performed': True
            }
        
        except Exception as e:
            return {
                'success': False,
                'error': str(e),
                'projectId': project_id
            }
 
# Example lookup function
def get_project_details(project_id: str) -> Dict:
    """Fetch project details (implement based on your system)."""
    # This would fetch from your project details endpoint
    response = requests.get(
        f"https://api.kruncher.ai/api/integration/project/{project_id}",
        headers={"Authorization": f"{API_KEY}"}
    )
    response.raise_for_status()
    data = response.json()
    
    return {
        'projectscoreId': data['projectscoreId'],
        'postanalysisoutputId': data['postanalysisoutputId']
    }
 
# Usage with auto-lookup
manager = CriteriaManager()
 
result = manager.update_with_lookup(
    "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "advertisingandmarketing",
    "Advertising & Marketing",
    get_project_details
)
 
if result['success']:
    print(f"✓ Criteria updated: {result['data']['criteriaName']}")
    print(f"  Lookup performed: {result['lookup_performed']}")
else:
    print(f"✗ Error: {result['error']}")

Result: Manager with optional auto-lookup of IDs.

Response Structure

Success Response (200 OK)

CODE

{
  "success": true,
  "data": {
    "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "criteriaCode": "advertisingandmarketing",
    "criteriaName": "Advertising & Marketing",
    "updatedAt": "2024-01-15T10:30:00Z",
    "scoreUpdated": true
  }
}

Response Fields

Field	Type	Description
`projectId`	string	The project UUID
`criteriaCode`	string	Code of the selected criteria
`criteriaName`	string	Display name of the criteria
`updatedAt`	string	ISO 8601 timestamp when updated
`scoreUpdated`	boolean	Whether project score was recalculated

Error Responses

400 Bad Request - Missing/Invalid Fields

CODE

{
  "success": false,
  "error": "projectscoreId is required"
}

404 Not Found - Project/Score Not Found

CODE

{
  "success": false,
  "error": "Project or score not found"
}

Common Criteria Codes

Code	Display Name
`advertisingandmarketing`	Advertising & Marketing
`softwareandtech`	Software & Technology
`ecommerce`	E-Commerce
`financialservices`	Financial Services
`healthcareandlifesciences`	Healthcare & Life Sciences
`manufacturingandlogistics`	Manufacturing & Logistics
`realestate`	Real Estate
`telecom`	Telecommunications

Common Patterns

Pattern 1: Update Based on Company Profile

CODE

async function updateCriteriaByProfile(projectId, companyProfile) {
  // Map profile to appropriate criteria
  const criteriaMap = {
    "tech_startup": { code: "softwareandtech", name: "Software & Technology" },
    "ecommerce": { code: "ecommerce", name: "E-Commerce" },
    "healthcare": { code: "healthcareandlifesciences", name: "Healthcare & Life Sciences" },
    "financial": { code: "financialservices", name: "Financial Services" }
  };
 
  const criteria = criteriaMap[companyProfile.type];
  
  if (!criteria) {
    throw new Error(`Unknown profile type: ${companyProfile.type}`);
  }
 
  return await setProjectCriteria(
    projectId,
    companyProfile.projectscoreId,
    companyProfile.postanalysisoutputId,
    criteria.code,
    criteria.name
  );
}

Pattern 2: Bulk Criteria Update

CODE

def update_criteria_for_portfolio(portfolio_projects: List[Dict]):
    """Update criteria for entire portfolio."""
    manager = CriteriaManager()
    
    # Group by investment thesis
    by_thesis = {}
    for project in portfolio_projects:
        thesis = project['investment_thesis']
        if thesis not in by_thesis:
            by_thesis[thesis] = []
        by_thesis[thesis].append(project)
    
    all_results = []
    
    for thesis, projects in by_thesis.items():
        criteria = map_thesis_to_criteria(thesis)
        
        projects_with_criteria = [
            {
                **p,
                'criteriaCode': criteria['code'],
                'criteriaName': criteria['name']
            }
            for p in projects
        ]
        
        results = manager.update_criteria_batch(projects_with_criteria)
        all_results.append(results)
    
    return all_results

Pattern 3: Criteria Update on Status Change

CODE

async function updateCriteriaOnStatusChange(projectId, newStatus) {
  // Update criteria based on new status
  const statusCriteriaMap = {
    "screening": "advertisingandmarketing",
    "diligence": "softwareandtech",
    "invested": "financialservices"
  };
 
  const criteriaCode = statusCriteriaMap[newStatus];
  
  if (!criteriaCode) {
    console.warn(`No criteria mapping for status: ${newStatus}`);
    return;
  }
 
  try {
    const result = await setProjectCriteria(
      projectId,
      projectDetails.projectscoreId,
      projectDetails.postanalysisoutputId,
      criteriaCode,
      getCriteriaName(criteriaCode)
    );
    
    console.log(`Updated criteria for ${newStatus}: ${result.data.criteriaName}`);
  } catch (error) {
    console.error(`Failed to update criteria: ${error.message}`);
  }
}

Best Practices

Before Updating

Verify all UUID fields are correct format
Ensure project and score exist
Validate criteria code matches your system
Check investment thesis alignment

ID Management

Store projectscoreId and postanalysisoutputId together
Consider caching these values per project
Validate UUIDs before making requests

Batch Operations

Update in logical groups (by thesis, by stage, etc.)
Add delays between requests to respect rate limits
Log all changes for audit trail
Handle partial failures gracefully

Error Recovery

Retry failed updates
Log projects that couldn’t be updated
Alert on validation errors
Maintain fallback criteria

Error Handling

Handling Missing IDs

CODE

async function setProjectCriteriaWithFallback(
  projectId,
  criteriaCode,
  criteriaName,
  getProjectDetails
) {
  try {
    const details = await getProjectDetails(projectId);
    
    return await setProjectCriteria(
      projectId,
      details.projectscoreId,
      details.postanalysisoutputId,
      criteriaCode,
      criteriaName
    );
  } catch (error) {
    console.error(`Cannot update criteria - missing project details: ${error}`);
    throw error;
  }
}

Validating Before Update

CODE

def validate_and_update_criteria(
    project_id: str,
    projectscore_id: str,
    postanalysisoutput_id: str,
    criteria_code: str,
    criteria_name: str
) -> bool:
    """Validate all fields before updating."""
    
    # Validate UUIDs
    import re
    uuid_pattern = r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
    
    for uuid_val in [project_id, projectscore_id, postanalysisoutput_id]:
        if not re.match(uuid_pattern, uuid_val, re.IGNORECASE):
            print(f"Invalid UUID: {uuid_val}")
            return False
    
    # Validate criteria
    valid_codes = [
        "advertisingandmarketing", "softwareandtech", "ecommerce",
        "financialservices", "healthcareandlifesciences"
    ]
    
    if criteria_code not in valid_codes:
        print(f"Invalid criteria code: {criteria_code}")
        return False
    
    # Proceed with update
    try:
        set_project_criteria(
            project_id, projectscore_id, postanalysisoutput_id,
            criteria_code, criteria_name
        )
        return True
    except Exception as e:
        print(f"Update failed: {e}")
        return False

Get Project Details - View project information
Update Project Status - Change project phase
View Analysis Output - See analysis results
Get Configuration - View available criteria

Troubleshooting

”Project not found” Error

Verify projectId is correct UUID format
Check project hasn’t been deleted
Confirm project exists in your environment

”Invalid criteria code” Error

Verify criteria code spelling (lowercase)
Check code is in supported list
Ensure criteria code matches your investment thesis

Score Not Updating

Verify scoreUpdated field in response
Check if criteria actually affects scoring
Review scoring configuration

Batch Updates Failing Partially

Check which projects have required IDs
Validate UUID formats for all records
Review failed items in error report

Need Help?

Finding project IDs? Use Get Project Details
Bulk updates? Use the CriteriaManager class for batch operations
Need lookup assistance? Implement the auto-lookup pattern with project details

Change Criteria

Endpoint

Headers

Request Body

Use Cases

Quick Start

cURL

Code Examples

JavaScript/TypeScript

Basic

With Error Handling

Batch Update

Auto-lookup

Python

Basic

With Error Handling

Batch Update

Auto-lookup

Response Structure

Success Response (200 OK)

Response Fields

Error Responses

400 Bad Request - Missing/Invalid Fields

404 Not Found - Project/Score Not Found

Common Criteria Codes

Common Patterns

Pattern 1: Update Based on Company Profile

Pattern 2: Bulk Criteria Update

Pattern 3: Criteria Update on Status Change

Best Practices

Before Updating

ID Management

Batch Operations

Error Recovery

Error Handling

Handling Missing IDs

Validating Before Update

Related Endpoints

Troubleshooting

”Project not found” Error

”Invalid criteria code” Error

Score Not Updating

Batch Updates Failing Partially

Need Help?