Update Project Criteria

Configure scoring criteria for a project to customize how companies are evaluated and analyzed. Use this endpoint to set industry-specific criteria, update scoring parameters, or refine evaluation metrics.

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	Must be `application/json`

Request Body

Field	Type	Required	Description
`projectId`	string	Yes	Unique identifier for the project
`projectscoreId`	string	Yes	Unique identifier for the project score
`postanalysisoutputId`	string	Yes	Unique identifier for the post-analysis output
`criteriaSelectedCode`	string	Yes	Code representing the selected criteria
`criteriaSelectedName`	string	Yes	Display name of the selected criteria

Getting Required IDs

To get the required IDs (projectscoreId and postanalysisoutputId):

Retrieve the project using the Find Companies endpoint
Extract IDs from the response:
- projectscoreId from projectScores[0].id
- postanalysisoutputId from the analysis output data
- projectId is returned when you create the project

Common Criteria Codes

Code	Name	Category
`advertisingandmarketing`	Advertising & Marketing	Industry
`saas`	SaaS	Business Model
`b2b`	B2B	Business Model
`b2c`	B2C	Business Model
`fintech`	FinTech	Industry
`healthtech`	HealthTech	Industry
`ecommerce`	E-commerce	Industry
`enterprise`	Enterprise Software	Industry
`ai`	Artificial Intelligence	Technology
`blockchain`	Blockchain	Technology

Note: Get the complete list of available criteria codes using the Config endpoint.

Code Examples

JavaScript/TypeScript

Basic

CODE

const API_KEY = "YOUR_API_KEY_HERE";
 
const response = await fetch("https://api.kruncher.ai/api/integration/project/criteria", {
  method: "POST",
  headers: {
    "Authorization": `${API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    projectId: "521a93a6-091d-4943-ba13-7c1a654a14ae",
    projectscoreId: "7c904e6a-e797-4b5b-8c28-feaf34b5ac75",
    postanalysisoutputId: "8756d0e9-8398-47ba-8d0e-f88ab53c38f3",
    criteriaSelectedCode: "advertisingandmarketing",
    criteriaSelectedName: "Advertising & Marketing"
  })
});
 
const result = await response.json();
console.log("Criteria updated:", result);

Result: Updates the project criteria to “Advertising & Marketing”.

Get IDs First

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
async function updateProjectCriteria(projectId, criteriaCode, criteriaName) {
  // Step 1: Get project details to extract required IDs
  const projectResponse = await fetch(`${BASE_URL}/integration/projects`, {
    headers: {
      "Authorization": `${API_KEY}`,
      "Content-Type": "application/json"
    }
  });
 
  const projects = await projectResponse.json();
  const project = projects.data.find(p => p.id === projectId);
 
  if (!project) {
    throw new Error(`Project ${projectId} not found`);
  }
 
  // Extract IDs from project data
  const projectscoreId = project.projectScores?.[0]?.id;
  const postanalysisoutputId = project.analyses?.[0]?.outputId; // Adjust based on your data structure
 
  if (!projectscoreId) {
    throw new Error("Project score ID not found");
  }
 
  if (!postanalysisoutputId) {
    throw new Error("Post-analysis output ID not found");
  }
 
  // Step 2: Update criteria
  const updateResponse = 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 (!updateResponse.ok) {
    throw new Error(`Update failed: ${updateResponse.status} ${updateResponse.statusText}`);
  }
 
  return await updateResponse.json();
}
 
// Usage
try {
  const result = await updateProjectCriteria(
    "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "saas",
    "SaaS"
  );
  console.log("Criteria updated successfully:", result);
} catch (error) {
  console.error("Failed to update criteria:", error.message);
}

Result: Automatically retrieves required IDs and updates criteria.

Advanced

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
class KruncherCriteriaAPI {
  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 getProjectDetails(projectId) {
    const result = await this.request('/integration/projects');
    const project = result.data.find(p => p.id === projectId);
 
    if (!project) {
      throw new Error(`Project ${projectId} not found`);
    }
 
    return {
      project,
      projectscoreId: project.projectScores?.[0]?.id,
      postanalysisoutputId: project.analyses?.[0]?.outputId
    };
  }
 
  async updateCriteria(projectId, criteriaCode, criteriaName, ids = null) {
    let projectscoreId, postanalysisoutputId;
 
    if (ids) {
      // Use provided IDs
      projectscoreId = ids.projectscoreId;
      postanalysisoutputId = ids.postanalysisoutputId;
    } else {
      // Fetch IDs automatically
      const details = await this.getProjectDetails(projectId);
      projectscoreId = details.projectscoreId;
      postanalysisoutputId = details.postanalysisoutputId;
    }
 
    if (!projectscoreId || !postanalysisoutputId) {
      throw new Error("Required IDs not found. Ensure project has scores and analysis.");
    }
 
    return await this.request('/integration/project/criteria', {
      method: 'POST',
      body: JSON.stringify({
        projectId,
        projectscoreId,
        postanalysisoutputId,
        criteriaSelectedCode: criteriaCode,
        criteriaSelectedName: criteriaName
      })
    });
  }
 
  async updateMultipleCriteria(projectId, criteriaList) {
    const details = await this.getProjectDetails(projectId);
    const results = [];
 
    for (const criteria of criteriaList) {
      try {
        const result = await this.updateCriteria(
          projectId,
          criteria.code,
          criteria.name,
          {
            projectscoreId: details.projectscoreId,
            postanalysisoutputId: details.postanalysisoutputId
          }
        );
        results.push({ 
          criteria: criteria.name, 
          success: true, 
          result 
        });
      } catch (error) {
        results.push({ 
          criteria: criteria.name, 
          success: false, 
          error: error.message 
        });
      }
    }
 
    return results;
  }
 
  async getAvailableCriteria() {
    const config = await this.request('/config');
    return config.criteria || [];
  }
}
 
// Usage examples
const api = new KruncherCriteriaAPI("YOUR_API_KEY_HERE");
 
// Update single criteria (auto-fetch IDs)
const result = await api.updateCriteria(
  "521a93a6-091d-4943-ba13-7c1a654a14ae",
  "saas",
  "SaaS"
);
console.log("Updated:", result);
 
// Update with explicit IDs
await api.updateCriteria(
  "521a93a6-091d-4943-ba13-7c1a654a14ae",
  "b2b",
  "B2B",
  {
    projectscoreId: "7c904e6a-e797-4b5b-8c28-feaf34b5ac75",
    postanalysisoutputId: "8756d0e9-8398-47ba-8d0e-f88ab53c38f3"
  }
);
 
// Update multiple criteria
const criteriaList = [
  { code: "saas", name: "SaaS" },
  { code: "b2b", name: "B2B" },
  { code: "ai", name: "Artificial Intelligence" }
];
 
const results = await api.updateMultipleCriteria(
  "521a93a6-091d-4943-ba13-7c1a654a14ae",
  criteriaList
);
 
console.log("Results:", results);
 
// Get available criteria
const availableCriteria = await api.getAvailableCriteria();
console.log("Available criteria:", availableCriteria);

Result: Full-featured client with auto-ID fetching and batch updates.

Python

Basic

CODE

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
url = "https://api.kruncher.ai/api/integration/project/criteria"
 
headers = {
    "Authorization": f"{API_KEY}",
    "Content-Type": "application/json"
}
 
data = {
    "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "projectscoreId": "7c904e6a-e797-4b5b-8c28-feaf34b5ac75",
    "postanalysisoutputId": "8756d0e9-8398-47ba-8d0e-f88ab53c38f3",
    "criteriaSelectedCode": "advertisingandmarketing",
    "criteriaSelectedName": "Advertising & Marketing"
}
 
response = requests.post(url, headers=headers, json=data)
 
if response.status_code == 200:
    print("Criteria updated:", response.json())
else:
    print(f"Error: {response.status_code} {response.text}")

Result: Updates project criteria to “Advertising & Marketing”.

Get IDs First

CODE

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
def get_project_ids(project_id):
    """Fetch required IDs from project data."""
    headers = {
        "Authorization": f"{API_KEY}",
        "Content-Type": "application/json"
    }
    
    response = requests.get(f"{BASE_URL}/integration/projects", headers=headers)
    response.raise_for_status()
    
    projects = response.json()
    project = next((p for p in projects['data'] if p['id'] == project_id), None)
    
    if not project:
        raise ValueError(f"Project {project_id} not found")
    
    projectscore_id = project.get('projectScores', [{}])[0].get('id')
    postanalysis_output_id = project.get('analyses', [{}])[0].get('outputId')
    
    if not projectscore_id:
        raise ValueError("Project score ID not found")
    if not postanalysis_output_id:
        raise ValueError("Post-analysis output ID not found")
    
    return projectscore_id, postanalysis_output_id
 
def update_project_criteria(project_id, criteria_code, criteria_name):
    """Update project criteria with automatic ID fetching."""
    # Get required IDs
    projectscore_id, postanalysis_output_id = get_project_ids(project_id)
    
    # Update criteria
    url = f"{BASE_URL}/integration/project/criteria"
    headers = {
        "Authorization": f"{API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "projectId": project_id,
        "projectscoreId": projectscore_id,
        "postanalysisoutputId": postanalysis_output_id,
        "criteriaSelectedCode": criteria_code,
        "criteriaSelectedName": criteria_name
    }
    
    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
    
    return response.json()
 
# Usage
try:
    result = update_project_criteria(
        "521a93a6-091d-4943-ba13-7c1a654a14ae",
        "saas",
        "SaaS"
    )
    print("Criteria updated successfully:", result)
except Exception as e:
    print(f"Failed to update criteria: {e}")

Result: Automatically fetches IDs and updates criteria.

Advanced

CODE

import requests
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
@dataclass
class CriteriaUpdate:
    code: str
    name: str
    success: bool = False
    result: Optional[Dict] = None
    error: Optional[str] = None
 
class KruncherCriteriaAPI:
    """Python client for Kruncher Criteria 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_project_ids(self, project_id: str) -> Tuple[str, str]:
        """
        Fetch required IDs from project data.
        
        Args:
            project_id: The project ID
        
        Returns:
            Tuple of (projectscore_id, postanalysis_output_id)
        
        Raises:
            ValueError: If project or IDs not found
        """
        response = self.session.get(f"{self.base_url}/integration/projects")
        response.raise_for_status()
        
        projects = response.json()
        project = next(
            (p for p in projects.get('data', []) if p['id'] == project_id),
            None
        )
        
        if not project:
            raise ValueError(f"Project {project_id} not found")
        
        projectscore_id = project.get('projectScores', [{}])[0].get('id')
        postanalysis_output_id = project.get('analyses', [{}])[0].get('outputId')
        
        if not projectscore_id:
            raise ValueError("Project score ID not found in project data")
        if not postanalysis_output_id:
            raise ValueError("Post-analysis output ID not found in project data")
        
        return projectscore_id, postanalysis_output_id
    
    def update_criteria(
        self,
        project_id: str,
        criteria_code: str,
        criteria_name: str,
        projectscore_id: Optional[str] = None,
        postanalysis_output_id: Optional[str] = None
    ) -> Dict:
        """
        Update project criteria.
        
        Args:
            project_id: The project ID
            criteria_code: Criteria code (e.g., 'saas')
            criteria_name: Criteria display name (e.g., 'SaaS')
            projectscore_id: Optional project score ID (auto-fetched if not provided)
            postanalysis_output_id: Optional output ID (auto-fetched if not provided)
        
        Returns:
            API response dict
        
        Raises:
            ValueError: If IDs cannot be determined
            requests.HTTPError: If API request fails
        """
        # Auto-fetch IDs if not provided
        if not projectscore_id or not postanalysis_output_id:
            projectscore_id, postanalysis_output_id = self.get_project_ids(project_id)
        
        payload = {
            "projectId": project_id,
            "projectscoreId": projectscore_id,
            "postanalysisoutputId": postanalysis_output_id,
            "criteriaSelectedCode": criteria_code,
            "criteriaSelectedName": criteria_name
        }
        
        response = self.session.post(
            f"{self.base_url}/integration/project/criteria",
            json=payload
        )
        response.raise_for_status()
        
        return response.json()
    
    def update_multiple_criteria(
        self,
        project_id: str,
        criteria_list: List[Dict[str, str]]
    ) -> List[CriteriaUpdate]:
        """
        Update multiple criteria for a project.
        
        Args:
            project_id: The project ID
            criteria_list: List of dicts with 'code' and 'name' keys
        
        Returns:
            List of CriteriaUpdate results
        """
        # Fetch IDs once
        try:
            projectscore_id, postanalysis_output_id = self.get_project_ids(project_id)
        except Exception as e:
            return [
                CriteriaUpdate(
                    code=c.get('code', ''),
                    name=c.get('name', ''),
                    success=False,
                    error=f"Failed to fetch IDs: {str(e)}"
                )
                for c in criteria_list
            ]
        
        results = []
        
        for criteria in criteria_list:
            try:
                result = self.update_criteria(
                    project_id,
                    criteria['code'],
                    criteria['name'],
                    projectscore_id,
                    postanalysis_output_id
                )
                results.append(CriteriaUpdate(
                    code=criteria['code'],
                    name=criteria['name'],
                    success=True,
                    result=result
                ))
            except Exception as e:
                results.append(CriteriaUpdate(
                    code=criteria['code'],
                    name=criteria['name'],
                    success=False,
                    error=str(e)
                ))
        
        return results
    
    def get_available_criteria(self) -> List[Dict]:
        """Get list of available criteria from config."""
        response = self.session.get(f"{self.base_url}/config")
        response.raise_for_status()
        
        config = response.json()
        return config.get('criteria', [])
 
# Usage examples
api = KruncherCriteriaAPI()
 
# Update single criteria (auto-fetch IDs)
try:
    result = api.update_criteria(
        "521a93a6-091d-4943-ba13-7c1a654a14ae",
        "saas",
        "SaaS"
    )
    print("Criteria updated:", result)
except Exception as e:
    print(f"Update failed: {e}")
 
# Update with explicit IDs
result = api.update_criteria(
    "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "b2b",
    "B2B",
    projectscore_id="7c904e6a-e797-4b5b-8c28-feaf34b5ac75",
    postanalysis_output_id="8756d0e9-8398-47ba-8d0e-f88ab53c38f3"
)
 
# Update multiple criteria
criteria_list = [
    {"code": "saas", "name": "SaaS"},
    {"code": "b2b", "name": "B2B"},
    {"code": "ai", "name": "Artificial Intelligence"}
]
 
results = api.update_multiple_criteria(
    "521a93a6-091d-4943-ba13-7c1a654a14ae",
    criteria_list
)
 
successful = [r for r in results if r.success]
failed = [r for r in results if not r.success]
 
print(f"Updated {len(successful)} criteria successfully")
if failed:
    print(f"Failed to update {len(failed)} criteria:")
    for f in failed:
        print(f"  - {f.name}: {f.error}")
 
# Get available criteria
available = api.get_available_criteria()
print(f"Available criteria: {len(available)}")

Result: Production-ready client with auto-ID fetching and batch processing.

cURL

Basic

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"
  }'

SaaS Criteria

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": "saas",
    "criteriaSelectedName": "SaaS"
  }'

B2B Criteria

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": "b2b",
    "criteriaSelectedName": "B2B"
  }'

Response

Success Response (200 OK)

CODE

{
  "code": "1000",
  "title": "Success",
  "description": "Criteria updated successfully",
  "data": {
    "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "criteriaCode": "advertisingandmarketing",
    "criteriaName": "Advertising & Marketing",
    "updatedAt": "2024-01-15T10:30:00Z"
  }
}

Error Responses

400 Bad Request

CODE

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

404 Not Found

CODE

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

Complete Workflow

Step-by-Step: Update Criteria for a New Project

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
// Step 1: Create a project
const createResponse = await fetch(`${BASE_URL}/integration/project`, {
  method: "POST",
  headers: {
    "Authorization": `${API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    name: "TechStartup",
    companyName: "TechStartup Inc.",
    companyWebsite: "https://techstartup.com",
    projectType: "projectAnalysisNoFile"
  })
});
 
const { project, analysisId } = await createResponse.json();
const projectId = project.id;
 
// Step 2: Wait for analysis to complete (or poll for status)
await new Promise(resolve => setTimeout(resolve, 5000));
 
// Step 3: Get project details to extract IDs
const projectsResponse = await fetch(`${BASE_URL}/integration/projects`, {
  headers: {
    "Authorization": `${API_KEY}`,
    "Content-Type": "application/json"
  }
});
 
const projects = await projectsResponse.json();
const projectData = projects.data.find(p => p.id === projectId);
 
const projectscoreId = projectData.projectScores[0].id;
const postanalysisoutputId = projectData.analyses[0].outputId;
 
// Step 4: Update criteria
const criteriaResponse = await fetch(`${BASE_URL}/integration/project/criteria`, {
  method: "POST",
  headers: {
    "Authorization": `${API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    projectId,
    projectscoreId,
    postanalysisoutputId,
    criteriaSelectedCode: "saas",
    criteriaSelectedName: "SaaS"
  })
});
 
const result = await criteriaResponse.json();
console.log("Criteria updated:", result);

Use Cases

Industry-Specific Scoring

CODE

# Set criteria based on company industry
industry_criteria_map = {
    "Software": {"code": "saas", "name": "SaaS"},
    "Finance": {"code": "fintech", "name": "FinTech"},
    "Healthcare": {"code": "healthtech", "name": "HealthTech"},
    "Retail": {"code": "ecommerce", "name": "E-commerce"}
}
 
company_industry = "Software"
criteria = industry_criteria_map.get(company_industry)
 
if criteria:
    api.update_criteria(project_id, criteria['code'], criteria['name'])

Business Model Based Criteria

CODE

// Set criteria based on business model
const businessModelCriteria = {
  "b2b": { code: "b2b", name: "B2B" },
  "b2c": { code: "b2c", name: "B2C" },
  "marketplace": { code: "marketplace", name: "Marketplace" }
};
 
const companyModel = "b2b";
const criteria = businessModelCriteria[companyModel];
 
await api.updateCriteria(projectId, criteria.code, criteria.name);

Multi-Criteria Update

CODE

# Apply multiple criteria tags
criteria_tags = [
    {"code": "saas", "name": "SaaS"},
    {"code": "b2b", "name": "B2B"},
    {"code": "enterprise", "name": "Enterprise Software"}
]
 
results = api.update_multiple_criteria(project_id, criteria_tags)
print(f"Applied {len([r for r in results if r.success])} criteria tags")

Best Practices

Get IDs Programmatically

Don’t hardcode projectscoreId and postanalysisoutputId
Fetch them from the project data before updating
Cache IDs if making multiple updates to the same project

Validate Criteria Codes

Use the Config endpoint to get valid criteria codes
Validate codes before sending updates
Handle invalid criteria gracefully

Error Handling

Check if project has scores and analysis before updating
Verify IDs exist in project data
Implement retry logic for transient failures

Performance

Batch criteria updates when possible
Cache project IDs to reduce API calls
Use appropriate delays between updates

Create Company - Create a project to apply criteria to
Find Companies - Get project data including score and analysis IDs
Config - Get list of available criteria codes
Update Analysis - Update other analysis entities

Troubleshooting

”Project score ID not found”

Ensure the project has been analyzed
Check that projectScores array is not empty
Verify analysis has completed successfully

”Post-analysis output ID not found”

Wait for analysis to complete
Check analysis status in project data
Ensure project type supports analysis

Invalid Criteria Code

Use the Config endpoint to get valid codes
Check for typos in criteria code
Verify criteria exists in your account settings

Need Help?

Custom criteria? Contact support to add new criteria types
Bulk updates? Ask about batch criteria update endpoints
Integration issues? Check the troubleshooting guide above

Update Project Criteria

Endpoint

Headers

Request Body

Getting Required IDs

Common Criteria Codes

Code Examples

JavaScript/TypeScript

Basic

Get IDs First

Advanced

Python

Basic

Get IDs First

Advanced

cURL

Basic

SaaS Criteria

B2B Criteria

Response

Success Response (200 OK)

Error Responses

400 Bad Request

404 Not Found

Complete Workflow

Step-by-Step: Update Criteria for a New Project

Use Cases

Industry-Specific Scoring

Business Model Based Criteria

Multi-Criteria Update

Best Practices

Get IDs Programmatically

Validate Criteria Codes

Error Handling

Performance

Related Endpoints

Troubleshooting

”Project score ID not found”

”Post-analysis output ID not found”

Invalid Criteria Code

Need Help?