Add Comment

Add a comment to a project for team collaboration, status updates, due diligence notes, or tracking decisions. Comments are timestamped and attributed to your API key’s account.

Endpoint

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

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	Yes	The unique identifier for the project (UUID format)
`comment`	string	Yes	The comment text to add (max 5000 characters)

Use Cases

Due Diligence Notes: Track analysis findings and decisions
Status Updates: Log project progress and milestone achievements
Team Collaboration: Share findings and feedback with team members
Decision Tracking: Document important decisions made about the project
Issue Tracking: Record bugs, concerns, or follow-up items
Audit Trail: Maintain compliance and audit documentation

Quick Start

cURL

CODE

curl -X POST "https://api.kruncher.ai/api/integration/project/comment" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "comment": "Completed due diligence review. Positive market traction and strong team."
  }'

Response:

CODE

{
  "success": true,
  "data": {
    "id": "comment_abc123",
    "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "comment": "Completed due diligence review. Positive market traction and strong team.",
    "createdAt": "2024-01-15T10:30:00Z",
    "createdBy": "api_user_xyz"
  }
}

Code Examples

JavaScript/TypeScript

Basic

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
async function addComment(projectId, comment) {
  const response = await fetch(`${BASE_URL}/integration/project/comment`, {
    method: "POST",
    headers: {
      "Authorization": `${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      projectId,
      comment
    })
  });
 
  if (!response.ok) {
    throw new Error(`Failed to add comment: ${response.statusText}`);
  }
 
  return await response.json();
}
 
// Usage
const result = await addComment(
  "521a93a6-091d-4943-ba13-7c1a654a14ae",
  "Completed due diligence review. Strong market fit."
);
 
console.log("Comment added:", result.data.id);

Result: Adds comment to project and returns comment ID.

With Error Handling

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
async function addComment(projectId, comment) {
  // Validate inputs
  if (!projectId || !comment) {
    throw new Error("projectId and comment are required");
  }
 
  if (comment.length > 5000) {
    throw new Error("Comment must be less than 5000 characters");
  }
 
  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(projectId)) {
    throw new Error("Invalid projectId format. Must be a valid UUID.");
  }
 
  const response = await fetch(`${BASE_URL}/integration/project/comment`, {
    method: "POST",
    headers: {
      "Authorization": `${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      projectId,
      comment
    })
  });
 
  if (response.status === 404) {
    throw new Error(`Project not found: ${projectId}`);
  }
 
  if (response.status === 400) {
    const error = await response.json();
    throw new Error(`Invalid request: ${error.message}`);
  }
 
  if (!response.ok) {
    throw new Error(`Failed to add comment: ${response.statusText}`);
  }
 
  return await response.json();
}
 
// Usage with error handling
try {
  const result = await addComment(
    "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "Completed due diligence review. Strong market fit."
  );
  console.log("Comment added:", result.data.id);
  console.log("Created at:", result.data.createdAt);
} catch (error) {
  console.error("Error adding comment:", error.message);
}

Result: Production-ready with validation and error handling.

Batch Comments

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
async function addComment(projectId, comment) {
  const response = await fetch(`${BASE_URL}/integration/project/comment`, {
    method: "POST",
    headers: {
      "Authorization": `${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({ projectId, comment })
  });
 
  if (!response.ok) {
    throw new Error(`Failed to add comment: ${response.statusText}`);
  }
 
  return await response.json();
}
 
async function addCommentsToProjects(projectComments) {
  /**
   * projectComments: Array of { projectId, comment } objects
   * Example: [
   *   { projectId: "...", comment: "..." },
   *   { projectId: "...", comment: "..." }
   * ]
   */
  
  const results = {
    successful: [],
    failed: []
  };
 
  // Add comments sequentially (respects rate limits)
  for (const { projectId, comment } of projectComments) {
    try {
      const result = await addComment(projectId, comment);
      results.successful.push({
        projectId,
        commentId: result.data.id,
        createdAt: result.data.createdAt
      });
      console.log(`✓ Comment added to ${projectId}`);
    } catch (error) {
      results.failed.push({
        projectId,
        error: error.message
      });
      console.error(`✗ Failed to add comment to ${projectId}: ${error.message}`);
    }
  }
 
  return results;
}
 
// Usage - batch add comments
const projectComments = [
  {
    projectId: "521a93a6-091d-4943-ba13-7c1a654a14ae",
    comment: "Completed due diligence. Strong fundamentals."
  },
  {
    projectId: "631b84b7-192e-4a54-ca24-8d765b725b95",
    comment: "Follow up on market expansion plans next week."
  },
  {
    projectId: "741c95c8-293f-5b65-db35-9e876c836ca6",
    comment: "Needs more clarity on unit economics."
  }
];
 
const results = await addCommentsToProjects(projectComments);
 
console.log(`Added ${results.successful.length} comments`);
console.log(`Failed: ${results.failed.length}`);
 
if (results.failed.length > 0) {
  console.log("Failed projects:", results.failed);
}

Result: Batch add comments with error tracking and reporting.

Python

Basic

CODE

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
def add_comment(project_id: str, comment: str) -> dict:
    """Add a comment to a project."""
    url = f"{BASE_URL}/integration/project/comment"
    
    headers = {
        "Authorization": f"{API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "projectId": project_id,
        "comment": comment
    }
    
    response = requests.post(url, json=payload, headers=headers)
    response.raise_for_status()
    
    return response.json()
 
# Usage
result = add_comment(
    "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "Completed due diligence review. Strong market fit."
)
 
print(f"Comment added: {result['data']['id']}")
print(f"Created at: {result['data']['createdAt']}")

Result: Simple comment addition.

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 add_comment(project_id: str, comment: str) -> Dict:
    """Add a comment to a project with full validation and error handling."""
    
    # Validate inputs
    if not project_id or not comment:
        raise ValueError("projectId and comment are required")
    
    if len(comment) > 5000:
        raise ValueError("Comment must be less than 5000 characters")
    
    # Validate UUID format
    uuid_pattern = r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
    if not re.match(uuid_pattern, project_id, re.IGNORECASE):
        raise ValueError(f"Invalid projectId format: {project_id}")
    
    url = f"{BASE_URL}/integration/project/comment"
    
    headers = {
        "Authorization": f"{API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "projectId": project_id,
        "comment": comment
    }
    
    try:
        response = requests.post(url, json=payload, headers=headers)
        
        if response.status_code == 404:
            raise ValueError(f"Project not found: {project_id}")
        
        if response.status_code == 400:
            error_data = response.json()
            raise ValueError(f"Invalid request: {error_data.get('message', 'Unknown error')}")
        
        response.raise_for_status()
        return response.json()
    
    except requests.exceptions.RequestException as e:
        raise Exception(f"Failed to add comment: {str(e)}")
 
# Usage with error handling
try:
    result = add_comment(
        "521a93a6-091d-4943-ba13-7c1a654a14ae",
        "Completed due diligence review. Strong market fit."
    )
    print(f"✓ Comment added: {result['data']['id']}")
    print(f"  Created at: {result['data']['createdAt']}")
except ValueError as e:
    print(f"✗ Validation error: {e}")
except Exception as e:
    print(f"✗ Error: {e}")

Result: Production-ready with comprehensive validation.

Batch Comments

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 ProjectCommentManager:
    """Manage adding comments to 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 add_comment(self, project_id: str, comment: str) -> Dict:
        """Add a single comment to a project."""
        url = f"{self.base_url}/integration/project/comment"
        
        payload = {
            "projectId": project_id,
            "comment": comment
        }
        
        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:
            error_data = response.json()
            raise ValueError(f"Invalid request: {error_data.get('message')}")
        
        response.raise_for_status()
        return response.json()
    
    def add_comments_batch(
        self,
        project_comments: List[Dict[str, str]]
    ) -> Dict:
        """
        Add comments to multiple projects.
        
        Args:
            project_comments: List of {'projectId': '...', 'comment': '...'} dicts
        
        Returns:
            Dictionary with 'successful' and 'failed' lists
        """
        results = {
            'successful': [],
            'failed': [],
            'timestamp': datetime.now().isoformat()
        }
        
        for item in project_comments:
            project_id = item.get('projectId')
            comment = item.get('comment')
            
            try:
                result = self.add_comment(project_id, comment)
                results['successful'].append({
                    'projectId': project_id,
                    'commentId': result['data']['id'],
                    'createdAt': result['data']['createdAt']
                })
                print(f"✓ Comment added to {project_id}")
            except Exception as e:
                results['failed'].append({
                    'projectId': project_id,
                    'error': str(e)
                })
                print(f"✗ Failed for {project_id}: {e}")
        
        return results
    
    def get_summary(self, results: Dict) -> str:
        """Generate a summary of batch operation results."""
        successful = len(results['successful'])
        failed = len(results['failed'])
        total = successful + failed
        
        summary = f"\nComment batch operation summary:\n"
        summary += f"  Total: {total}\n"
        summary += f"  Successful: {successful}\n"
        summary += f"  Failed: {failed}\n"
        
        if results['failed']:
            summary += "\nFailed projects:\n"
            for item in results['failed']:
                summary += f"  - {item['projectId']}: {item['error']}\n"
        
        return summary
 
# Usage
manager = ProjectCommentManager()
 
project_comments = [
    {
        "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae",
        "comment": "Completed due diligence. Strong fundamentals and market fit."
    },
    {
        "projectId": "631b84b7-192e-4a54-ca24-8d765b725b95",
        "comment": "Follow up on market expansion plans next week."
    },
    {
        "projectId": "741c95c8-293f-5b65-db35-9e876c836ca6",
        "comment": "Needs more clarity on unit economics. Requesting updated financials."
    }
]
 
results = manager.add_comments_batch(project_comments)
print(manager.get_summary(results))

Result: Production-ready batch manager with reporting.

Response Structure

Success Response (200 OK)

CODE

{
  "success": true,
  "data": {
    "id": "comment_abc123",
    "projectId": "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "comment": "Completed due diligence review. Positive market traction and strong team.",
    "createdAt": "2024-01-15T10:30:00Z",
    "createdBy": "api_user_xyz"
  }
}

Response Fields

Field	Type	Description
`id`	string	Unique comment identifier
`projectId`	string	The project UUID
`comment`	string	The comment text
`createdAt`	string	ISO 8601 timestamp when created
`createdBy`	string	Account/API key that created the comment

Error Responses

400 Bad Request - Missing/Invalid Fields

CODE

{
  "success": false,
  "error": "projectId and comment are required"
}

404 Not Found - Project Doesn’t Exist

CODE

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

401 Unauthorized - Invalid API Key

CODE

{
  "success": false,
  "error": "Unauthorized"
}

Common Patterns

Pattern 1: Log Due Diligence Findings

CODE

async function logDueDiligenceFindings(projectId, findings) {
  const comment = `
Due Diligence Findings:
- Market: ${findings.market}
- Team: ${findings.team}
- Product: ${findings.product}
- Financials: ${findings.financials}
- Status: ${findings.status}
  `.trim();
 
  const result = await addComment(projectId, comment);
  return result.data.id;
}
 
// Usage
const commentId = await logDueDiligenceFindings(
  "521a93a6-091d-4943-ba13-7c1a654a14ae",
  {
    market: "Large TAM, growing 25% YoY",
    team: "Experienced founders with relevant background",
    product: "MVP launched, early traction",
    financials: "Unit economics look positive",
    status: "Moving to next round"
  }
);
 
console.log(`Logged findings in comment: ${commentId}`);

Pattern 2: Status Update Trail

CODE

from datetime import datetime
 
def log_status_update(project_id: str, status: str, notes: str):
    """Log a status update with timestamp."""
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    
    comment = f"[{timestamp}] Status Update: {status}\n{notes}"
    
    result = add_comment(project_id, comment)
    return result['data']['id']
 
# Usage
comment_id = log_status_update(
    "521a93a6-091d-4943-ba13-7c1a654a14ae",
    "Moved to Screening",
    "Team confirmed working on next generation product. Strong market validation."
)

Pattern 3: Track Decision Points

CODE

async function logDecision(projectId, decision, reasoning, nextSteps) {
  const comment = `
DECISION: ${decision}
 
Reasoning:
${reasoning}
 
Next Steps:
${nextSteps}
  `.trim();
 
  const result = await addComment(projectId, comment);
  return result.data;
}
 
// Usage
const commentData = await logDecision(
  "521a93a6-091d-4943-ba13-7c1a654a14ae",
  "PASSED SCREENING",
  "Met all screening criteria. Market fit confirmed. Team qualified.",
  "Schedule follow-up meeting. Request detailed financials."
);

Best Practices

Comment Content

Use clear, concise language
Include timestamps for important milestones
Link to external documents or references when needed
Use structured format for complex information
Keep comments under 1000 characters for readability

Organization

One comment per topic/decision
Use consistent formatting for similar updates
Include context for future readers
Reference related projects or decisions

Collaboration

Comment with relevant details for team members
Include action items and next steps
Mention follow-up dates and owners
Tag important findings for visibility

Audit Trail

Log all key decisions
Document reasoning for decisions
Timestamp important milestones
Maintain compliance documentation

Error Handling

Handling 404 - Project Not Found

CODE

try {
  await addComment("invalid-project-id", "Test comment");
} catch (error) {
  if (error.message.includes("not found")) {
    console.error("Project does not exist. Check projectId.");
    // Fallback: search for project first
    const project = await findProject(projectName);
    if (project) {
      await addComment(project.id, "Test comment");
    }
  }
}

Handling Comment Too Long

CODE

def add_comment_with_truncation(project_id: str, comment: str, max_length: int = 5000):
    """Add comment, automatically truncate if too long."""
    if len(comment) > max_length:
        truncated = comment[:max_length - 3] + "..."
        print(f"Warning: Comment truncated from {len(comment)} to {len(truncated)} chars")
        comment = truncated
    
    return add_comment(project_id, comment)

Validate Before Adding

CODE

async function addCommentSafely(projectId, comment) {
  // Validate project exists first
  const projectExists = await checkProjectExists(projectId);
  
  if (!projectExists) {
    throw new Error(`Project ${projectId} does not exist`);
  }
  
  // Validate comment
  if (!comment || comment.trim().length === 0) {
    throw new Error("Comment cannot be empty");
  }
  
  if (comment.length > 5000) {
    throw new Error("Comment exceeds 5000 character limit");
  }
  
  // Add comment
  return await addComment(projectId, comment);
}

Add Comment

Endpoint

Headers

Request Body

Use Cases

Quick Start

cURL

Code Examples

JavaScript/TypeScript

Basic

With Error Handling

Batch Comments

Python

Basic

With Error Handling

Batch Comments

Response Structure

Success Response (200 OK)

Response Fields

Error Responses

400 Bad Request - Missing/Invalid Fields

404 Not Found - Project Doesn’t Exist

401 Unauthorized - Invalid API Key

Common Patterns

Pattern 1: Log Due Diligence Findings

Pattern 2: Status Update Trail

Pattern 3: Track Decision Points

Best Practices

Comment Content

Organization

Collaboration

Audit Trail

Error Handling

Handling 404 - Project Not Found

Handling Comment Too Long

Validate Before Adding

Related Endpoints

Troubleshooting

Comment Not Appearing

404 Error on Valid Project

Batch Operations Failing

Need Help?