Get All Mappings

Retrieve all entity mappings for your account, showing connections between Kruncher entities (person, company, opportunity) and external provider IDs. Use this to audit integrations, verify sync status, and manage cross-platform relationships.

Endpoint

GET https://api.kruncher.ai/api/integration/map/all

Headers

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

Query Parameters

This endpoint currently returns all mappings without pagination.

Use Cases

When to Use This Endpoint

Audit Integrations: Review all active mappings across providers
Verify Sync: Check which entities are mapped to external systems
Troubleshooting: Debug integration issues by viewing all mappings
Migration Validation: Confirm migration mappings were created correctly
Integration Cleanup: Identify and remove outdated mappings
Multi-Provider Management: See all provider connections at once

Code Examples

JavaScript/TypeScript

Basic

CODE

const API_KEY = "YOUR_API_KEY_HERE";
 
const response = await fetch("https://api.kruncher.ai/api/integration/map/all", {
  headers: {
    "Authorization": `${API_KEY}`,
    "Content-Type": "application/json"
  }
});
 
const result = await response.json();
 
console.log(`Total mappings: ${result.data.length}`);
console.log("Mappings:", result.data);

Result: Retrieves all mappings for your account.

With Filtering

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
async function getAllMappings() {
  const response = await fetch(`${BASE_URL}/integration/map/all`, {
    headers: {
      "Authorization": `${API_KEY}`,
      "Content-Type": "application/json"
    }
  });
 
  if (!response.ok) {
    throw new Error(`Failed to fetch mappings: ${response.statusText}`);
  }
 
  return await response.json();
}
 
function filterMappings(mappings, filters = {}) {
  let filtered = mappings;
 
  if (filters.entityType) {
    filtered = filtered.filter(m => m.entityType === filters.entityType);
  }
 
  if (filters.provider) {
    filtered = filtered.filter(m => m.provider === filters.provider);
  }
 
  if (filters.kruncherId) {
    filtered = filtered.filter(m => m.kruncherId === filters.kruncherId);
  }
 
  return filtered;
}
 
function groupByProvider(mappings) {
  return mappings.reduce((acc, mapping) => {
    if (!acc[mapping.provider]) {
      acc[mapping.provider] = [];
    }
    acc[mapping.provider].push(mapping);
    return acc;
  }, {});
}
 
function groupByEntityType(mappings) {
  return mappings.reduce((acc, mapping) => {
    if (!acc[mapping.entityType]) {
      acc[mapping.entityType] = [];
    }
    acc[mapping.entityType].push(mapping);
    return acc;
  }, {});
}
 
// Usage
const result = await getAllMappings();
const allMappings = result.data;
 
// Filter by provider
const affinityMappings = filterMappings(allMappings, { provider: "affinity" });
console.log(`Affinity mappings: ${affinityMappings.length}`);
 
// Filter by entity type
const companyMappings = filterMappings(allMappings, { entityType: "company" });
console.log(`Company mappings: ${companyMappings.length}`);
 
// Group by provider
const byProvider = groupByProvider(allMappings);
console.log("Mappings by provider:", Object.keys(byProvider));
 
// Group by entity type
const byType = groupByEntityType(allMappings);
console.log("Mappings by type:", Object.keys(byType));

Result: Retrieves and filters mappings by various criteria.

Advanced

CODE

const API_KEY = "YOUR_API_KEY_HERE";
const BASE_URL = "https://api.kruncher.ai/api";
 
class KruncherMappingReader {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseURL = BASE_URL;
    this.cache = null;
    this.lastFetch = null;
    this.cacheDuration = 300000; // 5 minutes
  }
 
  async fetchAllMappings(forceRefresh = false) {
    const now = Date.now();
 
    if (!forceRefresh && this.cache && (now - this.lastFetch < this.cacheDuration)) {
      return this.cache;
    }
 
    const response = await fetch(`${this.baseURL}/integration/map/all`, {
      headers: {
        "Authorization": `${this.apiKey}`,
        "Content-Type": "application/json"
      }
    });
 
    if (!response.ok) {
      throw new Error(`Failed to fetch mappings: ${response.statusText}`);
    }
 
    const result = await response.json();
    this.cache = result.data;
    this.lastFetch = now;
 
    return this.cache;
  }
 
  async getMappingsByProvider(provider) {
    const mappings = await this.fetchAllMappings();
    return mappings.filter(m => m.provider === provider);
  }
 
  async getMappingsByEntityType(entityType) {
    const mappings = await this.fetchAllMappings();
    return mappings.filter(m => m.entityType === entityType);
  }
 
  async findMappingByKruncherId(kruncherId) {
    const mappings = await this.fetchAllMappings();
    return mappings.find(m => m.kruncherId === kruncherId) || null;
  }
 
  async findMappingByExternalId(externalId, provider = null) {
    const mappings = await this.fetchAllMappings();
    return mappings.find(m => 
      m.externalId === externalId && 
      (provider ? m.provider === provider : true)
    ) || null;
  }
 
  async getExternalId(kruncherId, provider) {
    const mappings = await this.fetchAllMappings();
    const mapping = mappings.find(
      m => m.kruncherId === kruncherId && m.provider === provider
    );
    return mapping?.externalId || null;
  }
 
  async getKruncherId(externalId, provider) {
    const mappings = await this.fetchAllMappings();
    const mapping = mappings.find(
      m => m.externalId === externalId && m.provider === provider
    );
    return mapping?.kruncherId || null;
  }
 
  async getProviders() {
    const mappings = await this.fetchAllMappings();
    return [...new Set(mappings.map(m => m.provider))];
  }
 
  async getEntityTypes() {
    const mappings = await this.fetchAllMappings();
    return [...new Set(mappings.map(m => m.entityType))];
  }
 
  async getMappingStats() {
    const mappings = await this.fetchAllMappings();
 
    const byProvider = mappings.reduce((acc, m) => {
      acc[m.provider] = (acc[m.provider] || 0) + 1;
      return acc;
    }, {});
 
    const byEntityType = mappings.reduce((acc, m) => {
      acc[m.entityType] = (acc[m.entityType] || 0) + 1;
      return acc;
    }, {});
 
    return {
      total: mappings.length,
      byProvider,
      byEntityType,
      providers: Object.keys(byProvider).length,
      entityTypes: Object.keys(byEntityType).length,
      oldestMapping: mappings.reduce((oldest, m) => 
        !oldest || new Date(m.createdAt) < new Date(oldest.createdAt) ? m : oldest,
        null
      ),
      newestMapping: mappings.reduce((newest, m) => 
        !newest || new Date(m.createdAt) > new Date(newest.createdAt) ? m : newest,
        null
      )
    };
  }
 
  async findUnmappedEntities(kruncherEntities, provider) {
    const mappings = await this.fetchAllMappings();
    const mappedIds = new Set(
      mappings
        .filter(m => m.provider === provider)
        .map(m => m.kruncherId)
    );
 
    return kruncherEntities.filter(entity => !mappedIds.has(entity.id));
  }
 
  async validateMappings(externalSystem, provider) {
    const mappings = await this.getMappingsByProvider(provider);
    const validation = {
      valid: [],
      invalid: [],
      missing: []
    };
 
    for (const mapping of mappings) {
      const exists = await externalSystem.entityExists(mapping.externalId);
      
      if (exists) {
        validation.valid.push(mapping);
      } else {
        validation.invalid.push(mapping);
      }
    }
 
    return validation;
  }
 
  async exportMappings(format = 'json') {
    const mappings = await this.fetchAllMappings();
 
    if (format === 'csv') {
      return this._toCSV(mappings);
    }
 
    return JSON.stringify(mappings, null, 2);
  }
 
  _toCSV(mappings) {
    const headers = ['id', 'entityType', 'provider', 'kruncherId', 'externalId', 'createdAt', 'updatedAt'];
    const rows = mappings.map(m => 
      headers.map(h => JSON.stringify(m[h] || '')).join(',')
    );
    
    return [headers.join(','), ...rows].join('\n');
  }
 
  clearCache() {
    this.cache = null;
    this.lastFetch = null;
  }
}
 
// Usage examples
const reader = new KruncherMappingReader("YOUR_API_KEY_HERE");
 
// Get all mappings
const allMappings = await reader.fetchAllMappings();
console.log(`Total mappings: ${allMappings.length}`);
 
// Get mappings by provider
const affinityMappings = await reader.getMappingsByProvider("affinity");
console.log(`Affinity: ${affinityMappings.length}`);
 
// Find specific mapping
const mapping = await reader.findMappingByKruncherId("proj_123");
console.log("Mapping:", mapping);
 
// Get external ID
const externalId = await reader.getExternalId("proj_123", "affinity");
console.log("External ID:", externalId);
 
// Get Kruncher ID
const kruncherId = await reader.getKruncherId("affinity_org_456", "affinity");
console.log("Kruncher ID:", kruncherId);
 
// Get statistics
const stats = await reader.getMappingStats();
console.log("Stats:", stats);
 
// Find unmapped entities
const unmapped = await reader.findUnmappedEntities(allCompanies, "affinity");
console.log(`Unmapped companies: ${unmapped.length}`);
 
// Export mappings
const csvExport = await reader.exportMappings('csv');
console.log("CSV export ready");
 
// Get all providers
const providers = await reader.getProviders();
console.log("Active providers:", providers);

Result: Full-featured reader with caching, filtering, and validation.

Python

Basic

CODE

import requests
 
API_KEY = "YOUR_API_KEY_HERE"
url = "https://api.kruncher.ai/api/integration/map/all"
 
headers = {
    "Authorization": f"{API_KEY}",
    "Content-Type": "application/json"
}
 
response = requests.get(url, headers=headers)
 
if response.status_code == 200:
    result = response.json()
    print(f"Total mappings: {len(result['data'])}")
    print(f"Mappings: {result['data']}")
else:
    print(f"Error: {response.status_code} {response.text}")

Result: Retrieves all mappings for your account.

With Filtering

CODE

import requests
from collections import defaultdict
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
def get_all_mappings():
    """Fetch all mappings."""
    url = f"{BASE_URL}/integration/map/all"
    
    headers = {
        "Authorization": f"{API_KEY}",
        "Content-Type": "application/json"
    }
    
    response = requests.get(url, headers=headers)
    response.raise_for_status()
    
    return response.json()['data']
 
def filter_mappings(mappings, entity_type=None, provider=None, kruncher_id=None):
    """Filter mappings by criteria."""
    filtered = mappings
    
    if entity_type:
        filtered = [m for m in filtered if m['entityType'] == entity_type]
    
    if provider:
        filtered = [m for m in filtered if m['provider'] == provider]
    
    if kruncher_id:
        filtered = [m for m in filtered if m['kruncherId'] == kruncher_id]
    
    return filtered
 
def group_by_provider(mappings):
    """Group mappings by provider."""
    grouped = defaultdict(list)
    for mapping in mappings:
        grouped[mapping['provider']].append(mapping)
    return dict(grouped)
 
def group_by_entity_type(mappings):
    """Group mappings by entity type."""
    grouped = defaultdict(list)
    for mapping in mappings:
        grouped[mapping['entityType']].append(mapping)
    return dict(grouped)
 
# Usage
mappings = get_all_mappings()
print(f"Total mappings: {len(mappings)}")
 
# Filter by provider
affinity_mappings = filter_mappings(mappings, provider="affinity")
print(f"Affinity mappings: {len(affinity_mappings)}")
 
# Filter by entity type
company_mappings = filter_mappings(mappings, entity_type="company")
print(f"Company mappings: {len(company_mappings)}")
 
# Group by provider
by_provider = group_by_provider(mappings)
for provider, items in by_provider.items():
    print(f"{provider}: {len(items)} mappings")
 
# Group by entity type
by_type = group_by_entity_type(mappings)
for entity_type, items in by_type.items():
    print(f"{entity_type}: {len(items)} mappings")

Result: Retrieves and organizes mappings by various criteria.

Advanced

CODE

import requests
import time
import csv
from typing import Dict, List, Optional, Set
from dataclasses import dataclass
from datetime import datetime
from collections import defaultdict
 
API_KEY = "YOUR_API_KEY_HERE"
BASE_URL = "https://api.kruncher.ai/api"
 
@dataclass
class Mapping:
    id: str
    entity_type: str
    provider: str
    kruncher_id: str
    external_id: str
    created_at: str
    updated_at: str
    customer_id: str
 
class KruncherMappingReader:
    """Comprehensive mapping reader and analyzer."""
    
    def __init__(self, api_key: str = API_KEY, cache_ttl: int = 300):
        self.api_key = api_key
        self.base_url = BASE_URL
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"{api_key}",
            "Content-Type": "application/json"
        })
        self.cache = None
        self.last_fetch = None
        self.cache_ttl = cache_ttl
    
    def fetch_all_mappings(self, force_refresh: bool = False) -> List[Dict]:
        """
        Fetch all mappings with caching.
        
        Args:
            force_refresh: Force refresh even if cache is valid
        
        Returns:
            List of mapping dictionaries
        """
        now = time.time()
        
        if not force_refresh and self.cache and self.last_fetch:
            if (now - self.last_fetch) < self.cache_ttl:
                return self.cache
        
        response = self.session.get(f"{self.base_url}/integration/map/all")
        response.raise_for_status()
        
        result = response.json()
        self.cache = result.get('data', [])
        self.last_fetch = now
        
        return self.cache
    
    def get_mappings_by_provider(self, provider: str) -> List[Dict]:
        """Get all mappings for a specific provider."""
        mappings = self.fetch_all_mappings()
        return [m for m in mappings if m.get('provider') == provider]
    
    def get_mappings_by_entity_type(self, entity_type: str) -> List[Dict]:
        """Get all mappings for a specific entity type."""
        mappings = self.fetch_all_mappings()
        return [m for m in mappings if m.get('entityType') == entity_type]
    
    def find_mapping_by_kruncher_id(
        self,
        kruncher_id: str,
        provider: Optional[str] = None
    ) -> Optional[Dict]:
        """Find mapping by Kruncher ID."""
        mappings = self.fetch_all_mappings()
        for mapping in mappings:
            if mapping.get('kruncherId') == kruncher_id:
                if provider is None or mapping.get('provider') == provider:
                    return mapping
        return None
    
    def find_mapping_by_external_id(
        self,
        external_id: str,
        provider: Optional[str] = None
    ) -> Optional[Dict]:
        """Find mapping by external ID."""
        mappings = self.fetch_all_mappings()
        for mapping in mappings:
            if mapping.get('externalId') == external_id:
                if provider is None or mapping.get('provider') == provider:
                    return mapping
        return None
    
    def get_external_id(self, kruncher_id: str, provider: str) -> Optional[str]:
        """Get external ID for a Kruncher ID and provider."""
        mapping = self.find_mapping_by_kruncher_id(kruncher_id, provider)
        return mapping.get('externalId') if mapping else None
    
    def get_kruncher_id(self, external_id: str, provider: str) -> Optional[str]:
        """Get Kruncher ID for an external ID and provider."""
        mapping = self.find_mapping_by_external_id(external_id, provider)
        return mapping.get('kruncherId') if mapping else None
    
    def get_providers(self) -> List[str]:
        """Get list of all active providers."""
        mappings = self.fetch_all_mappings()
        return list(set(m.get('provider') for m in mappings))
    
    def get_entity_types(self) -> List[str]:
        """Get list of all entity types."""
        mappings = self.fetch_all_mappings()
        return list(set(m.get('entityType') for m in mappings))
    
    def get_mapping_stats(self) -> Dict:
        """Get comprehensive mapping statistics."""
        mappings = self.fetch_all_mappings()
        
        by_provider = defaultdict(int)
        by_entity_type = defaultdict(int)
        
        for mapping in mappings:
            by_provider[mapping.get('provider')] += 1
            by_entity_type[mapping.get('entityType')] += 1
        
        # Find oldest and newest
        if mappings:
            sorted_by_date = sorted(
                mappings,
                key=lambda m: datetime.fromisoformat(m.get('createdAt', '').replace('Z', '+00:00'))
            )
            oldest = sorted_by_date[0]
            newest = sorted_by_date[-1]
        else:
            oldest = newest = None
        
        return {
            'total': len(mappings),
            'by_provider': dict(by_provider),
            'by_entity_type': dict(by_entity_type),
            'providers_count': len(by_provider),
            'entity_types_count': len(by_entity_type),
            'oldest_mapping': oldest,
            'newest_mapping': newest
        }
    
    def find_unmapped_entities(
        self,
        kruncher_entities: List[Dict],
        provider: str
    ) -> List[Dict]:
        """Find entities that aren't mapped to a provider."""
        mappings = self.get_mappings_by_provider(provider)
        mapped_ids = set(m.get('kruncherId') for m in mappings)
        
        return [
            entity for entity in kruncher_entities
            if entity.get('id') not in mapped_ids
        ]
    
    def validate_mappings(
        self,
        external_system_checker,
        provider: str
    ) -> Dict:
        """Validate mappings against external system."""
        mappings = self.get_mappings_by_provider(provider)
        
        validation = {
            'valid': [],
            'invalid': [],
            'total': len(mappings)
        }
        
        for mapping in mappings:
            exists = external_system_checker(mapping.get('externalId'))
            
            if exists:
                validation['valid'].append(mapping)
            else:
                validation['invalid'].append(mapping)
        
        return validation
    
    def export_to_csv(self, filename: str) -> None:
        """Export mappings to CSV file."""
        mappings = self.fetch_all_mappings()
        
        if not mappings:
            print("No mappings to export")
            return
        
        fieldnames = ['id', 'entityType', 'provider', 'kruncherId', 
                      'externalId', 'createdAt', 'updatedAt', 'customerId']
        
        with open(filename, 'w', newline='') as csvfile:
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(mappings)
        
        print(f"Exported {len(mappings)} mappings to {filename}")
    
    def export_to_json(self, filename: str) -> None:
        """Export mappings to JSON file."""
        import json
        
        mappings = self.fetch_all_mappings()
        
        with open(filename, 'w') as jsonfile:
            json.dump(mappings, jsonfile, indent=2)
        
        print(f"Exported {len(mappings)} mappings to {filename}")
    
    def get_mapping_summary(self) -> str:
        """Get human-readable summary of mappings."""
        stats = self.get_mapping_stats()
        
        summary = [
            f"Total Mappings: {stats['total']}",
            f"\nBy Provider:",
        ]
        
        for provider, count in stats['by_provider'].items():
            summary.append(f"  - {provider}: {count}")
        
        summary.append(f"\nBy Entity Type:")
        for entity_type, count in stats['by_entity_type'].items():
            summary.append(f"  - {entity_type}: {count}")
        
        if stats['oldest_mapping']:
            summary.append(f"\nOldest mapping created: {stats['oldest_mapping']['createdAt']}")
        
        if stats['newest_mapping']:
            summary.append(f"Newest mapping created: {stats['newest_mapping']['createdAt']}")
        
        return '\n'.join(summary)
    
    def clear_cache(self):
        """Clear mapping cache."""
        self.cache = None
        self.last_fetch = None
 
# Usage examples
reader = KruncherMappingReader()
 
# Get all mappings
all_mappings = reader.fetch_all_mappings()
print(f"Total mappings: {len(all_mappings)}")
 
# Get mappings by provider
affinity_mappings = reader.get_mappings_by_provider("affinity")
print(f"Affinity: {len(affinity_mappings)}")
 
# Find specific mapping
mapping = reader.find_mapping_by_kruncher_id("proj_123")
print(f"Mapping: {mapping}")
 
# Get external ID
external_id = reader.get_external_id("proj_123", "affinity")
print(f"External ID: {external_id}")
 
# Get Kruncher ID
kruncher_id = reader.get_kruncher_id("affinity_org_456", "affinity")
print(f"Kruncher ID: {kruncher_id}")
 
# Get statistics
stats = reader.get_mapping_stats()
print(f"Stats: {stats}")
 
# Get summary
summary = reader.get_mapping_summary()
print(summary)
 
# Find unmapped entities
unmapped = reader.find_unmapped_entities(all_companies, "affinity")
print(f"Unmapped companies: {len(unmapped)}")
 
# Export to CSV
reader.export_to_csv('mappings.csv')
 
# Export to JSON
reader.export_to_json('mappings.json')
 
# Get all providers
providers = reader.get_providers()
print(f"Active providers: {providers}")

Result: Production-ready reader with caching, validation, and export.

cURL

Basic

CODE

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

With jq

CODE

# Get all mappings
curl -s -X GET "https://api.kruncher.ai/api/integration/map/all" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '.'
 
# Count mappings by provider
curl -s -X GET "https://api.kruncher.ai/api/integration/map/all" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '.data | group_by(.provider) | map({provider: .[0].provider, count: length})'
 
# Get only Affinity mappings
curl -s -X GET "https://api.kruncher.ai/api/integration/map/all" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '.data[] | select(.provider == "affinity")'
 
# Find mapping by Kruncher ID
curl -s -X GET "https://api.kruncher.ai/api/integration/map/all" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '.data[] | select(.kruncherId == "proj_123")'
 
# Count by entity type
curl -s -X GET "https://api.kruncher.ai/api/integration/map/all" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '.data | group_by(.entityType) | map({type: .[0].entityType, count: length})'

Export

CODE

# Export to JSON file
curl -s -X GET "https://api.kruncher.ai/api/integration/map/all" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '.data' > mappings.json
 
echo "Mappings exported to mappings.json"
 
# Export to CSV
curl -s -X GET "https://api.kruncher.ai/api/integration/map/all" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq -r '.data[] | [.id, .entityType, .provider, .kruncherId, .externalId, .createdAt, .updatedAt] | @csv' \
  > mappings.csv
 
echo "Mappings exported to mappings.csv"
 
# Get unique providers
curl -s -X GET "https://api.kruncher.ai/api/integration/map/all" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq -r '.data[].provider' | sort -u
 
# Get summary stats
curl -s -X GET "https://api.kruncher.ai/api/integration/map/all" \
  -H "Authorization: YOUR_API_KEY_HERE" \
  | jq '{
      total: .data | length,
      providers: .data | map(.provider) | unique,
      entityTypes: .data | map(.entityType) | unique
    }'

Response Structure

Success Response (200 OK)

CODE

{
  "code": "1000",
  "title": "Successful",
  "description": "",
  "data": [
    {
      "id": "mapping_abc123",
      "entityType": "company",
      "provider": "affinity",
      "kruncherId": "proj_123",
      "externalId": "affinity_org_456",
      "createdAt": "2024-01-15T10:30:00Z",
      "updatedAt": "2024-01-15T10:30:00Z",
      "customerId": "customer_xyz789"
    },
    {
      "id": "mapping_def456",
      "entityType": "person",
      "provider": "attio",
      "kruncherId": "person_abc",
      "externalId": "attio_contact_123",
      "createdAt": "2024-01-16T14:20:00Z",
      "updatedAt": "2024-01-16T14:20:00Z",
      "customerId": "customer_xyz789"
    },
    {
      "id": "mapping_ghi789",
      "entityType": "opportunity",
      "provider": "pipedrive",
      "kruncherId": "opp_def",
      "externalId": "pipedrive_deal_789",
      "createdAt": "2024-01-17T09:15:00Z",
      "updatedAt": "2024-01-17T09:15:00Z",
      "customerId": "customer_xyz789"
    }
  ]
}

Response Fields

Field	Type	Description
`id`	string	Unique mapping identifier
`entityType`	string	Type: `person`, `company`, or `opportunity`
`provider`	string	External provider name
`kruncherId`	string	Kruncher internal ID
`externalId`	string	External system ID
`createdAt`	string	ISO 8601 timestamp when created
`updatedAt`	string	ISO 8601 timestamp when last updated
`customerId`	string	Your customer ID

Common Use Cases

Audit All Integrations

CODE

const reader = new KruncherMappingReader(API_KEY);
const stats = await reader.getMappingStats();
 
console.log(`Total mappings: ${stats.total}`);
console.log(`Active providers: ${stats.providers_count}`);
console.log("\nBreakdown by provider:");
for (const [provider, count] of Object.entries(stats.byProvider)) {
  console.log(`  ${provider}: ${count} mappings`);
}

Find Unmapped Companies

CODE

reader = KruncherMappingReader()
 
# Get all Kruncher companies
all_companies = get_kruncher_companies()
 
# Find companies not mapped to Affinity
unmapped = reader.find_unmapped_entities(all_companies, "affinity")
 
print(f"Found {len(unmapped)} companies not synced to Affinity:")
for company in unmapped:
    print(f"  - {company['name']} (ID: {company['id']})")

Validate External IDs

CODE

// Check if all mapped external IDs still exist in Affinity
async function validateAffinityMappings() {
  const reader = new KruncherMappingReader(API_KEY);
  const affinityMappings = await reader.getMappingsByProvider("affinity");
  
  const invalid = [];
  
  for (const mapping of affinityMappings) {
    const exists = await checkAffinityOrgExists(mapping.externalId);
    if (!exists) {
      invalid.push(mapping);
    }
  }
  
  if (invalid.length > 0) {
    console.log(`Found ${invalid.length} invalid mappings:`);
    invalid.forEach(m => console.log(`  - ${m.kruncherId} → ${m.externalId}`));
  } else {
    console.log("All mappings valid!");
  }
}

Export for Backup

CODE

# Export all mappings for backup
reader = KruncherMappingReader()
 
# Export to CSV
reader.export_to_csv('backups/mappings_2024-01-15.csv')
 
# Export to JSON
reader.export_to_json('backups/mappings_2024-01-15.json')
 
print("Backup complete!")

Lookup External ID

CODE

// Quick lookup of external ID for syncing
const reader = new KruncherMappingReader(API_KEY);
 
const kruncherId = "proj_123";
const affinityId = await reader.getExternalId(kruncherId, "affinity");
 
if (affinityId) {
  // Sync data to Affinity using their ID
  await updateAffinityOrganization(affinityId, companyData);
} else {
  console.log("No Affinity mapping found for this company");
}

Best Practices

Caching

Cache mappings locally for 5-15 minutes
Refresh cache after creating new mappings
Use force refresh sparingly
Share cache across application

Validation

Periodically validate external IDs still exist
Check for orphaned mappings
Monitor mapping creation vs deletion rates
Alert on validation failures

Performance

Don’t fetch on every request
Filter locally after fetching once
Use indexed lookups for large datasets
Consider pagination for very large result sets

Data Integrity

Export mappings regularly for backup
Verify mapping counts match expectations
Monitor for duplicate mappings
Track mapping age and staleness

Create Mapping - Create new entity mappings
Delete Mapping - Remove mappings (contact support)
Find Companies - Get Kruncher entity IDs
Integrations - Provider-specific guides

Troubleshooting

No Mappings Returned

Verify API key is correct
Check if any mappings have been created
Ensure you’re using correct endpoint
Try creating a test mapping

Missing Mappings

Check if mappings were created successfully
Verify correct customer account
Look for deletion logs
Contact support for recovery

Duplicate Entries

Same Kruncher ID with multiple external IDs for one provider
Contact support to resolve duplicates
Review mapping creation logic

Performance Issues

Large number of mappings (>10,000)
Implement local caching
Filter on server side if available
Contact support for pagination options

Need Help?

Large export? Contact support for bulk export options
Delete mappings? Request mapping cleanup assistance
Custom queries? Ask about filtering options
Migration? Get help with bulk mapping management

Get All Mappings

Endpoint

Headers

Query Parameters

Use Cases

When to Use This Endpoint

Code Examples

JavaScript/TypeScript

Basic

With Filtering

Advanced

Python

Basic

With Filtering

Advanced

cURL

Basic

With jq

Export

Response Structure

Success Response (200 OK)

Response Fields

Common Use Cases

Audit All Integrations

Find Unmapped Companies

Validate External IDs

Export for Backup

Lookup External ID

Best Practices

Caching

Validation

Performance

Data Integrity

Related Endpoints

Troubleshooting

No Mappings Returned

Missing Mappings

Duplicate Entries

Performance Issues

Need Help?