Assign Company to List

Add companies to or remove them from project lists. Use this to organize your portfolio by industry, stage, geography, or custom categories.

Endpoint

POST https://api.kruncher.ai/api/integration/projectlist/assign

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 project/company identifier
`projectlistId`	string	Yes	Unique list identifier
`addTrueRemoveFalse`	boolean	Yes	`true` to add, `false` to remove

How to Get IDs

Project ID:

Get from Find Companies endpoint
Returned when Creating a Company

List ID:

Get from Project Lists endpoint
Available in your organization’s list configuration

Use Cases

When to Assign Companies

Portfolio Organization: Group companies by stage, industry, or geography
Team Assignment: Create lists for different team members
Investment Stages: Organize by funding round or status
Geographic Focus: Group by region or country
Market Segments: Segment by vertical or market
Bulk Operations: Organize multiple companies at once
Dynamic Updates: Update list membership as deals progress

Code Examples

JavaScript/TypeScript

Single Assignment

CODE

const API_KEY = "YOUR_API_KEY_HERE";
 
// Add company to list
const response = await fetch("https://api.kruncher.ai/api/integration/projectlist/assign", {
  method: "POST",
  headers: {
    "Authorization": `${API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    projectId: "proj_123",
    projectlistId: "list_tech_startups",
    addTrueRemoveFalse: true
  })
});
 
const result = await response.json();
console.log("Company added to list:", result);
 
// Remove company from list
const removeResponse = await fetch("https://api.kruncher.ai/api/integration/projectlist/assign", {
  method: "POST",
  headers: {
    "Authorization": `${API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    projectId: "proj_123",
    projectlistId: "list_tech_startups",
    addTrueRemoveFalse: false
  })
});
 
console.log("Company removed from list:", await removeResponse.json());

Result: Adds or removes a company from a list.

Batch Operations

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
async function assignCompanyToList(projectId, listId, add = true) {
  const response = await fetch(`${BASE_URL}/integration/projectlist/assign`, {
    method: "POST",
    headers: {
      "Authorization": `${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      projectId,
      projectlistId: listId,
      addTrueRemoveFalse: add
    })
  });
 
  if (!response.ok) {
    throw new Error(`Assignment failed: ${response.statusText}`);
  }
 
  return await response.json();
}
 
async function addCompanyToList(projectId, listId) {
  return await assignCompanyToList(projectId, listId, true);
}
 
async function removeCompanyFromList(projectId, listId) {
  return await assignCompanyToList(projectId, listId, false);
}
 
async function bulkAddCompanies(projectIds, listId) {
  const results = {
    successful: [],
    failed: [],
    total: projectIds.length
  };
 
  for (const projectId of projectIds) {
    try {
      const result = await addCompanyToList(projectId, listId);
      results.successful.push({ projectId, result });
      console.log(`✓ Added ${projectId}`);
    } catch (error) {
      results.failed.push({ projectId, error: error.message });
      console.error(`✗ Failed to add ${projectId}: ${error.message}`);
    }
  }
 
  return results;
}
 
async function bulkRemoveCompanies(projectIds, listId) {
  const results = {
    successful: [],
    failed: [],
    total: projectIds.length
  };
 
  for (const projectId of projectIds) {
    try {
      const result = await removeCompanyFromList(projectId, listId);
      results.successful.push({ projectId, result });
      console.log(`✓ Removed ${projectId}`);
    } catch (error) {
      results.failed.push({ projectId, error: error.message });
      console.error(`✗ Failed to remove ${projectId}: ${error.message}`);
    }
  }
 
  return results;
}
 
// Usage
// Add single company
await addCompanyToList("proj_123", "list_tech");
 
// Remove single company
await removeCompanyFromList("proj_123", "list_tech");
 
// Bulk add companies
const companiesToAdd = ["proj_1", "proj_2", "proj_3"];
const addResults = await bulkAddCompanies(companiesToAdd, "list_tech");
console.log(`Added: ${addResults.successful.length}/${addResults.total}`);
 
// Bulk remove companies
const companiesToRemove = ["proj_4", "proj_5"];
const removeResults = await bulkRemoveCompanies(companiesToRemove, "list_tech");
console.log(`Removed: ${removeResults.successful.length}/${removeResults.total}`);

Result: Bulk operations with error tracking.

Advanced

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
class ProjectListAssignmentManager {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = BASE_URL;
  }
 
  async assignCompany(projectId, listId, add = true) {
    const response = await fetch(`${this.baseURL}/integration/projectlist/assign`, {
      method: "POST",
      headers: {
        "Authorization": `${this.apiKey}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        projectId,
        projectlistId: listId,
        addTrueRemoveFalse: add
      })
    });
 
    if (!response.ok) {
      const error = await response.json().catch(() => ({ 
        message: response.statusText 
      }));
      throw new Error(`Assignment failed: ${error.message || error.description}`);
    }
 
    return await response.json();
  }
 
  async addToList(projectId, listId) {
    return await this.assignCompany(projectId, listId, true);
  }
 
  async removeFromList(projectId, listId) {
    return await this.assignCompany(projectId, listId, false);
  }
 
  async bulkAdd(projectIds, listId, options = {}) {
    const { 
      batchSize = 10, 
      delayMs = 100,
      stopOnError = false 
    } = options;
 
    const results = {
      successful: [],
      failed: [],
      total: projectIds.length
    };
 
    for (let i = 0; i < projectIds.length; i += batchSize) {
      const batch = projectIds.slice(i, i + batchSize);
      
      const batchPromises = batch.map(async (projectId) => {
        try {
          const result = await this.addToList(projectId, listId);
          return { success: true, projectId, result };
        } catch (error) {
          return { success: false, projectId, error: error.message };
        }
      });
 
      const batchResults = await Promise.all(batchPromises);
 
      for (const result of batchResults) {
        if (result.success) {
          results.successful.push(result);
        } else {
          results.failed.push(result);
          if (stopOnError) {
            return results;
          }
        }
      }
 
      // Delay between batches
      if (i + batchSize < projectIds.length) {
        await new Promise(resolve => setTimeout(resolve, delayMs));
      }
    }
 
    return results;
  }
 
  async bulkRemove(projectIds, listId, options = {}) {
    const { 
      batchSize = 10, 
      delayMs = 100,
      stopOnError = false 
    } = options;
 
    const results = {
      successful: [],
      failed: [],
      total: projectIds.length
    };
 
    for (let i = 0; i < projectIds.length; i += batchSize) {
      const batch = projectIds.slice(i, i + batchSize);
      
      const batchPromises = batch.map(async (projectId) => {
        try {
          const result = await this.removeFromList(projectId, listId);
          return { success: true, projectId, result };
        } catch (error) {
          return { success: false, projectId, error: error.message };
        }
      });
 
      const batchResults = await Promise.all(batchPromises);
 
      for (const result of batchResults) {
        if (result.success) {
          results.successful.push(result);
        } else {
          results.failed.push(result);
          if (stopOnError) {
            return results;
          }
        }
      }
 
      // Delay between batches
      if (i + batchSize < projectIds.length) {
        await new Promise(resolve => setTimeout(resolve, delayMs));
      }
    }
 
    return results;
  }
 
  async reorganizeList(projectId, fromListId, toListId) {
    try {
      await this.removeFromList(projectId, fromListId);
      await this.addToList(projectId, toListId);
      return {
        success: true,
        message: `Moved from ${fromListId} to ${toListId}`
      };
    } catch (error) {
      return {
        success: false,
        error: error.message
      };
    }
  }
 
  async moveCompaniesToList(projectIds, fromListId, toListId) {
    const results = {
      successful: [],
      failed: []
    };
 
    for (const projectId of projectIds) {
      const result = await this.reorganizeList(projectId, fromListId, toListId);
      
      if (result.success) {
        results.successful.push({ projectId, result });
      } else {
        results.failed.push({ projectId, error: result.error });
      }
    }
 
    return results;
  }
 
  getAssignmentStats(results) {
    return {
      total: results.total,
      successful: results.successful.length,
      failed: results.failed.length,
      successRate: (results.successful.length / results.total * 100).toFixed(2) + '%',
      failedProjects: results.failed.map(f => f.projectId)
    };
  }
}
 
// Usage
const manager = new ProjectListAssignmentManager("YOUR_API_KEY_HERE");
 
// Single assignment
await manager.addToList("proj_123", "list_tech");
 
// Bulk add
const companyIds = ["proj_1", "proj_2", "proj_3", "proj_4", "proj_5"];
const addResults = await manager.bulkAdd(companyIds, "list_tech", {
  batchSize: 10,
  delayMs: 100
});
 
console.log("Add results:", manager.getAssignmentStats(addResults));
 
// Bulk remove
const removeResults = await manager.bulkRemove(companyIds, "list_tech");
console.log("Remove results:", manager.getAssignmentStats(removeResults));
 
// Move companies between lists
const moveResults = await manager.moveCompaniesToList(
  ["proj_1", "proj_2"],
  "list_seed",
  "list_seriesA"
);
 
console.log("Moved successfully:", moveResults.successful.length);

Result: Full-featured manager with bulk operations and list reorganization.

Python

Single Assignment

CODE

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
url = "https://api.kruncher.ai/api/integration/projectlist/assign"
 
headers = {
    "Authorization": f"{API_KEY}",
    "Content-Type": "application/json"
}
 
# Add company to list
data = {
    "projectId": "proj_123",
    "projectlistId": "list_tech_startups",
    "addTrueRemoveFalse": True
}
 
response = requests.post(url, headers=headers, json=data)
 
if response.status_code == 200:
    print("Company added:", response.json())
else:
    print(f"Error: {response.status_code} {response.text}")
 
# Remove company from list
data["addTrueRemoveFalse"] = False
response = requests.post(url, headers=headers, json=data)
print("Company removed:", response.json())

Result: Add or remove company from a list.

Batch Operations

CODE

import requests
from typing import List, Dict
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
def assign_company_to_list(project_id: str, list_id: str, add: bool = True) -> Dict:
    """Assign or unassign a company to/from a list."""
    url = f"{BASE_URL}/integration/projectlist/assign"
    
    headers = {
        "Authorization": f"{API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "projectId": project_id,
        "projectlistId": list_id,
        "addTrueRemoveFalse": add
    }
    
    response = requests.post(url, headers=headers, json=payload)
    response.raise_for_status()
    
    return response.json()
 
def add_company_to_list(project_id: str, list_id: str) -> Dict:
    """Add company to list."""
    return assign_company_to_list(project_id, list_id, True)
 
def remove_company_from_list(project_id: str, list_id: str) -> Dict:
    """Remove company from list."""
    return assign_company_to_list(project_id, list_id, False)
 
def bulk_add_companies(project_ids: List[str], list_id: str) -> Dict:
    """Add multiple companies to a list."""
    results = {
        'successful': [],
        'failed': [],
        'total': len(project_ids)
    }
    
    for project_id in project_ids:
        try:
            result = add_company_to_list(project_id, list_id)
            results['successful'].append({'projectId': project_id, 'result': result})
            print(f"✓ Added {project_id}")
        except Exception as e:
            results['failed'].append({'projectId': project_id, 'error': str(e)})
            print(f"✗ Failed to add {project_id}: {e}")
    
    return results
 
def bulk_remove_companies(project_ids: List[str], list_id: str) -> Dict:
    """Remove multiple companies from a list."""
    results = {
        'successful': [],
        'failed': [],
        'total': len(project_ids)
    }
    
    for project_id in project_ids:
        try:
            result = remove_company_from_list(project_id, list_id)
            results['successful'].append({'projectId': project_id, 'result': result})
            print(f"✓ Removed {project_id}")
        except Exception as e:
            results['failed'].append({'projectId': project_id, 'error': str(e)})
            print(f"✗ Failed to remove {project_id}: {e}")
    
    return results
 
# Usage
# Add single
add_company_to_list("proj_123", "list_tech")
 
# Remove single
remove_company_from_list("proj_123", "list_tech")
 
# Bulk add
company_ids = ["proj_1", "proj_2", "proj_3"]
results = bulk_add_companies(company_ids, "list_tech")
print(f"Added: {len(results['successful'])}/{results['total']}")
 
# Bulk remove
results = bulk_remove_companies(company_ids, "list_tech")
print(f"Removed: {len(results['successful'])}/{results['total']}")

Result: Bulk operations with detailed reporting.

Advanced

CODE

import requests
import time
from typing import Dict, List, Optional
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
class ProjectListAssignmentManager:
    """Manage company assignments to project lists."""
    
    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 assign_company(
        self,
        project_id: str,
        list_id: str,
        add: bool = True
    ) -> Dict:
        """
        Assign or unassign a company to/from a list.
        
        Args:
            project_id: Company/project ID
            list_id: List ID
            add: True to add, False to remove
        
        Returns:
            API response
        """
        payload = {
            "projectId": project_id,
            "projectlistId": list_id,
            "addTrueRemoveFalse": add
        }
        
        response = self.session.post(
            f"{self.base_url}/integration/projectlist/assign",
            json=payload
        )
        response.raise_for_status()
        
        return response.json()
    
    def add_to_list(self, project_id: str, list_id: str) -> Dict:
        """Add company to list."""
        return self.assign_company(project_id, list_id, True)
    
    def remove_from_list(self, project_id: str, list_id: str) -> Dict:
        """Remove company from list."""
        return self.assign_company(project_id, list_id, False)
    
    def bulk_add(
        self,
        project_ids: List[str],
        list_id: str,
        batch_size: int = 10,
        delay_seconds: float = 0.1
    ) -> Dict:
        """
        Add multiple companies to a list.
        
        Args:
            project_ids: List of project IDs
            list_id: Target list ID
            batch_size: Number of requests per batch
            delay_seconds: Delay between batches
        
        Returns:
            Results with successful and failed assignments
        """
        results = {
            'successful': [],
            'failed': [],
            'total': len(project_ids)
        }
        
        for i in range(0, len(project_ids), batch_size):
            batch = project_ids[i:i + batch_size]
            
            for project_id in batch:
                try:
                    result = self.add_to_list(project_id, list_id)
                    results['successful'].append({
                        'projectId': project_id,
                        'result': result
                    })
                except Exception as e:
                    results['failed'].append({
                        'projectId': project_id,
                        'error': str(e)
                    })
            
            # Delay between batches
            if i + batch_size < len(project_ids):
                time.sleep(delay_seconds)
        
        return results
    
    def bulk_remove(
        self,
        project_ids: List[str],
        list_id: str,
        batch_size: int = 10,
        delay_seconds: float = 0.1
    ) -> Dict:
        """Remove multiple companies from a list."""
        results = {
            'successful': [],
            'failed': [],
            'total': len(project_ids)
        }
        
        for i in range(0, len(project_ids), batch_size):
            batch = project_ids[i:i + batch_size]
            
            for project_id in batch:
                try:
                    result = self.remove_from_list(project_id, list_id)
                    results['successful'].append({
                        'projectId': project_id,
                        'result': result
                    })
                except Exception as e:
                    results['failed'].append({
                        'projectId': project_id,
                        'error': str(e)
                    })
            
            # Delay between batches
            if i + batch_size < len(project_ids):
                time.sleep(delay_seconds)
        
        return results
    
    def reorganize_company(
        self,
        project_id: str,
        from_list_id: str,
        to_list_id: str
    ) -> Dict:
        """Move a company from one list to another."""
        try:
            self.remove_from_list(project_id, from_list_id)
            self.add_to_list(project_id, to_list_id)
            
            return {
                'success': True,
                'projectId': project_id,
                'message': f'Moved from {from_list_id} to {to_list_id}'
            }
        except Exception as e:
            return {
                'success': False,
                'projectId': project_id,
                'error': str(e)
            }
    
    def reorganize_multiple(
        self,
        project_ids: List[str],
        from_list_id: str,
        to_list_id: str
    ) -> Dict:
        """Move multiple companies between lists."""
        results = {
            'successful': [],
            'failed': []
        }
        
        for project_id in project_ids:
            result = self.reorganize_company(project_id, from_list_id, to_list_id)
            
            if result['success']:
                results['successful'].append(result)
            else:
                results['failed'].append(result)
        
        return results
    
    def get_stats(self, results: Dict) -> Dict:
        """Get statistics from assignment results."""
        total = results.get('total', 0)
        successful = len(results.get('successful', []))
        failed = len(results.get('failed', []))
        
        return {
            'total': total,
            'successful': successful,
            'failed': failed,
            'success_rate': f"{successful / total * 100:.2f}%" if total > 0 else "0%",
            'failed_projects': [f['projectId'] for f in results.get('failed', [])]
        }
 
# Usage examples
manager = ProjectListAssignmentManager()
 
# Single assignment
manager.add_to_list("proj_123", "list_tech")
 
# Bulk add
company_ids = ["proj_1", "proj_2", "proj_3", "proj_4", "proj_5"]
results = manager.bulk_add(
    company_ids,
    "list_tech",
    batch_size=10,
    delay_seconds=0.1
)
 
stats = manager.get_stats(results)
print(f"Add results: {stats}")
 
# Reorganize companies
move_results = manager.reorganize_multiple(
    ["proj_1", "proj_2"],
    "list_seed",
    "list_seriesA"
)
 
print(f"Moved: {len(move_results['successful'])} successful")

Result: Production-ready manager with batching and reorganization.

cURL

Add Company

CODE

curl -X POST "https://api.kruncher.ai/api/integration/projectlist/assign" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "projectId": "proj_123",
    "projectlistId": "list_tech_startups",
    "addTrueRemoveFalse": true
  }'

Remove Company

CODE

curl -X POST "https://api.kruncher.ai/api/integration/projectlist/assign" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "projectId": "proj_123",
    "projectlistId": "list_tech_startups",
    "addTrueRemoveFalse": false
  }'

Batch

CODE

#!/bin/bash
 
API_KEY="YOUR_API_KEY_HERE"
LIST_ID="list_tech_startups"
PROJECTS=("proj_1" "proj_2" "proj_3")
 
for PROJECT_ID in "${PROJECTS[@]}"; do
  echo "Adding $PROJECT_ID to $LIST_ID..."
  
  curl -s -X POST "https://api.kruncher.ai/api/integration/projectlist/assign" \
    -H "Authorization: $API_KEY" \
    -H "Content-Type: application/json" \
    -d "{
      \"projectId\": \"$PROJECT_ID\",
      \"projectlistId\": \"$LIST_ID\",
      \"addTrueRemoveFalse\": true
    }" | jq '.'
done

Response

Success Response (200 OK)

CODE

{
  "code": "1000",
  "title": "Success",
  "description": "Company assignment successful",
  "data": {
    "projectId": "proj_123",
    "projectlistId": "list_tech_startups",
    "action": "added",
    "timestamp": "2024-01-15T10:30:00Z"
  }
}

Error Responses

400 Bad Request

CODE

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

404 Not Found

CODE

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

409 Conflict

CODE

{
  "code": "4090",
  "title": "Conflict",
  "description": "Company is already in this list"
}

Common Workflows

Workflow 1: Organize New Company

CODE

// When creating a new company, assign it to appropriate lists
const projectId = "newly_created_project";
const manager = new ProjectListAssignmentManager(API_KEY);
 
// Add to industry list
await manager.addToList(projectId, "list_technology");
 
// Add to stage list
await manager.addToList(projectId, "list_seed_stage");
 
// Add to geographic list
await manager.addToList(projectId, "list_us_west");
 
console.log("Company organized into all lists");

Workflow 2: Bulk Portfolio Organization

CODE

manager = ProjectListAssignmentManager()
 
# Get all companies (from retrieve endpoint)
companies = get_all_companies()
 
# Organize companies by stage
for company in companies:
    stage = company['stage']
    
    if stage == 'seed':
        manager.add_to_list(company['id'], 'list_seed')
    elif stage == 'seriesA':
        manager.add_to_list(company['id'], 'list_seriesA')
    elif stage == 'seriesB':
        manager.add_to_list(company['id'], 'list_seriesB')
 
print("Portfolio organized by stage")

Workflow 3: Move Companies Between Lists

CODE

// When a company moves from seed to Series A
const manager = new ProjectListAssignmentManager(API_KEY);
 
const results = await manager.moveCompaniesToList(
  ["proj_1", "proj_2"],
  "list_seed",
  "list_seriesA"
);
 
console.log(`Promoted ${results.successful.length} companies to Series A`);

Workflow 4: Clean Up Old Lists

CODE

manager = ProjectListAssignmentManager()
 
# Remove all companies from old list
old_companies = get_companies_in_list("list_2023_rejected")
 
results = manager.bulk_remove(
    [c['id'] for c in old_companies],
    "list_2023_rejected"
)
 
print(f"Removed {len(results['successful'])} companies from old list")

Best Practices

Before Assigning

Verify project exists
Verify list exists
Check project isn’t already in list (avoid duplicates)
Log assignment operations
Track assignment history

Bulk Operations

Use batch processing for large datasets
Add delays between batches (100-200ms)
Track failed assignments
Retry failed assignments
Log all operations

List Management

Keep lists organized and named clearly
Archive old lists instead of deleting
Document list purposes and owners
Review list membership periodically
Remove inactive companies

Error Handling

CODE

try {
  await manager.addToList(projectId, listId);
} catch (error) {
  if (error.message.includes("already")) {
    // Company already in list
    console.log("Already assigned");
  } else if (error.message.includes("not found")) {
    // Project or list not found
    console.log("Invalid project or list ID");
  } else {
    // Other error
    console.error("Assignment failed:", error);
  }
}

Project Lists - Get available lists
Find Companies - Get project IDs
Create Company - Create new projects
Update Project Status - Track progress

Troubleshooting

Company Already in List

Check current list membership before adding
Remove first, then re-add if needed
Verify you want to add to this list

Invalid Project or List ID

Get correct IDs from Project Lists
Get correct IDs from Find Companies
Verify IDs are not swapped

Bulk Assignment Failing

Check batch size (10-50 recommended)
Add delays between batches
Check for rate limiting
Retry failed assignments

Assignment Not Persisting

Verify response indicates success
Check assignment immediately after
Confirm you have proper permissions
Contact support if issue persists

Need Help?

List not found? See Project Lists to get list IDs
Bulk operations? Use batch processing with delays
Moving companies? Use reorganize methods for safe transfers
Performance issues? Implement caching and batching

Assign Company to List

Endpoint

Headers

Request Body

How to Get IDs

Use Cases

When to Assign Companies

Code Examples

JavaScript/TypeScript

Single Assignment

Batch Operations

Advanced

Python

Single Assignment

Batch Operations

Advanced

cURL

Add Company

Remove Company

Batch

Response

Success Response (200 OK)

Error Responses

400 Bad Request

404 Not Found

409 Conflict

Common Workflows

Workflow 1: Organize New Company

Workflow 2: Bulk Portfolio Organization

Workflow 3: Move Companies Between Lists

Workflow 4: Clean Up Old Lists

Best Practices

Before Assigning

Bulk Operations

List Management

Error Handling

Related Endpoints

Troubleshooting

Company Already in List

Invalid Project or List ID

Bulk Assignment Failing

Assignment Not Persisting

Need Help?