---
title: "회사 관리"
description: "Tajo 엔터프라이즈 로열티 프로그램을 위해 Brevo CRM에서 B2B 회사와 기업 계정을 관리합니다"
url: https://tajo.io/kr/docs/sales-crm/companies/
markdown: https://tajo.io/kr/docs/sales-crm/companies.md
lang: ko-KR
robots: noindex
---

Tajo 사전 이용 신청

이름과 회사 이메일 주소를 입력하세요. Tajo 이용 신청을 확인할 수 있는 링크를 이메일로 보내드립니다.

# 회사 관리

Brevo CRM Companies API를 사용하면 Tajo 플랫폼 안에서 엔터프라이즈 로열티 프로그램을 위한 B2B 관계와 기업 계정을 관리할 수 있습니다.

## 개요

회사 관리는 다음과 같은 경우에 꼭 필요합니다.

- 대량 리워드와 등급 관리를 포함한 **기업 로열티 프로그램**
- 전담 어카운트 매니저가 배정되는 **B2B 고객 관계**
- 회사 단위 애널리틱스를 활용한 **엔터프라이즈 영업 추적**
- 로열티를 중앙에서 관리하는 **다지점 사업체**
- 특별 가격과 리워드를 제공하는 **파트너 및 리셀러 프로그램**

## 빠른 시작

### 회사 생성

```http
POST https://api.brevo.com/v3/companies
Content-Type: application/json
api-key: YOUR_API_KEY

{
  "name": "Acme Corporation",
  "attributes": {
    "industry": "Technology",
    "company_size": "500-1000",
    "website": "https://acmecorp.com",
    "phone": "+1-555-0123",
    "address": "123 Business Ave, Tech City, CA 90210",
    "loyalty_program": "Enterprise Plus",
    "loyalty_tier": "Corporate Gold",
    "annual_spend": 250000,
    "contract_value": 500000,
    "renewal_date": "2024-12-31",
    "account_manager": "Sarah Johnson",
    "industry_vertical": "Software Services"
  }
}
```

### 응답

```json
{
  "id": "comp_123456789",
  "name": "Acme Corporation",
  "created_at": "2024-01-25T14:30:00Z",
  "updated_at": "2024-01-25T14:30:00Z"
}
```

## 엔터프라이즈 로열티 연동

### 기업 계정 설정

로열티 프로그램과 연동되는 기업 계정을 종합적으로 설정합니다.

```javascript
class TajoEnterpriseService {
  constructor() {
    this.companiesApi = new CompaniesApi();
    this.contactsApi = new ContactsApi();
  }

  async createCorporateAccount(companyData) {
    // Create company with loyalty attributes
    const company = {
      name: companyData.name,
      attributes: {
        // Business Information
        industry: companyData.industry,
        company_size: companyData.employeeCount,
        website: companyData.website,
        phone: companyData.phone,
        address: companyData.address,
        tax_id: companyData.taxId,

        // Loyalty Program Data
        loyalty_program: 'Enterprise Plus',
        loyalty_tier: this.determineEnterpriseTier(companyData.annualSpend),
        loyalty_points: 0,
        annual_spend: companyData.annualSpend || 0,
        lifetime_value: companyData.lifetimeValue || 0,

        // Contract Information
        contract_value: companyData.contractValue,
        contract_start: companyData.contractStart,
        renewal_date: companyData.renewalDate,
        payment_terms: companyData.paymentTerms,

        // Account Management
        account_manager: companyData.accountManager,
        success_manager: companyData.successManager,
        billing_contact: companyData.billingContact,

        // Preferences
        bulk_discount_eligible: true,
        volume_rewards_enabled: true,
        consolidated_billing: companyData.consolidatedBilling,
        multi_location: companyData.hasMultipleLocations
      }
    };

    try {
      const response = await this.companiesApi.createCompany(company);

      // Set up corporate loyalty tracking
      await this.initializeCorporateLoyalty(response.id, companyData);

      return response;
    } catch (error) {
      console.error('Error creating corporate account:', error);
      throw error;
    }
  }

  determineEnterpriseTier(annualSpend) {
    if (annualSpend >= 1000000) return 'Enterprise Diamond';
    if (annualSpend >= 500000) return 'Enterprise Platinum';
    if (annualSpend >= 250000) return 'Enterprise Gold';
    if (annualSpend >= 100000) return 'Enterprise Silver';
    return 'Enterprise Bronze';
  }

  async initializeCorporateLoyalty(companyId, companyData) {
    // Create corporate loyalty program entry
    await loyaltyService.createCorporateProgram({
      companyId: companyId,
      programType: 'enterprise',
      tier: this.determineEnterpriseTier(companyData.annualSpend),
      volumeDiscounts: this.calculateVolumeDiscounts(companyData.annualSpend),
      bulkRewards: true,
      dedicatedSupport: true
    });

    // Set up automated tracking
    await loyaltyService.setupCorporateTracking(companyId, {
      trackVolumeDiscounts: true,
      trackBulkOrders: true,
      trackMultiLocation: companyData.hasMultipleLocations,
      consolidateReporting: true
    });
  }
}
```

### 기업 등급 관리

B2B 계정을 위한 정교한 등급 관리를 구현합니다.

```javascript
class CorporateTierManager {
  constructor() {
    this.tierThresholds = {
      'Enterprise Bronze': { minSpend: 0, benefits: ['basic_support', 'standard_shipping'] },
      'Enterprise Silver': { minSpend: 100000, benefits: ['priority_support', 'free_shipping', '5%_discount'] },
      'Enterprise Gold': { minSpend: 250000, benefits: ['dedicated_manager', 'expedited_shipping', '10%_discount'] },
      'Enterprise Platinum': { minSpend: 500000, benefits: ['premium_support', 'custom_integration', '15%_discount'] },
      'Enterprise Diamond': { minSpend: 1000000, benefits: ['white_glove_service', 'unlimited_integration', '20%_discount'] }
    };
  }

  async evaluateTierUpgrade(companyId, currentSpend) {
    const company = await this.companiesApi.getCompany(companyId);
    const currentTier = company.attributes.loyalty_tier;
    const newTier = this.calculateTier(currentSpend);

    if (newTier !== currentTier && this.isUpgrade(currentTier, newTier)) {
      await this.processTierUpgrade(companyId, currentTier, newTier, currentSpend);
    }

    return newTier;
  }

  async processTierUpgrade(companyId, oldTier, newTier, currentSpend) {
    // Update company tier
    await this.companiesApi.updateCompany(companyId, {
      attributes: {
        loyalty_tier: newTier,
        tier_upgrade_date: new Date().toISOString(),
        previous_tier: oldTier,
        annual_spend: currentSpend
      }
    });

    // Notify account team
    const company = await this.companiesApi.getCompany(companyId);
    await this.notifyAccountTeam(company, {
      upgradeType: 'tier_upgrade',
      oldTier: oldTier,
      newTier: newTier,
      newBenefits: this.tierThresholds[newTier].benefits
    });

    // Send congratulations to company contacts
    await this.sendTierUpgradeNotifications(companyId, {
      companyName: company.name,
      newTier: newTier,
      benefits: this.tierThresholds[newTier].benefits
    });

    // Apply new tier benefits
    await this.applyTierBenefits(companyId, newTier);
  }

  calculateTier(annualSpend) {
    const tiers = Object.entries(this.tierThresholds)
      .sort(([,a], [,b]) => b.minSpend - a.minSpend);

    for (const [tier, threshold] of tiers) {
      if (annualSpend >= threshold.minSpend) {
        return tier;
      }
    }
    return 'Enterprise Bronze';
  }
}
```

## 다지점 관리

### 지점 계층 구조

복잡한 다지점 기업 구조를 관리합니다.

```javascript
class MultiLocationManager {
  async createLocationHierarchy(parentCompanyId, locations) {
    const locationCompanies = [];

    for (const location of locations) {
      const locationCompany = {
        name: `${location.companyName} - ${location.locationName}`,
        attributes: {
          parent_company_id: parentCompanyId,
          location_type: location.type, // 'headquarters', 'branch', 'franchise'
          location_name: location.locationName,
          address: location.address,
          phone: location.phone,
          manager: location.manager,
          employee_count: location.employeeCount,

          // Loyalty Program Inheritance
          loyalty_program: 'Enterprise Plus',
          inherit_parent_tier: true,
          location_budget: location.budget,
          location_spending_limit: location.spendingLimit,

          // Performance Tracking
          location_performance_target: location.target,
          location_rewards_pool: location.rewardsPool
        }
      };

      const createdLocation = await this.companiesApi.createCompany(locationCompany);
      locationCompanies.push(createdLocation);

      // Link employees to location
      await this.linkEmployeesToLocation(createdLocation.id, location.employees);
    }

    // Set up consolidated reporting
    await this.setupConsolidatedReporting(parentCompanyId, locationCompanies);

    return locationCompanies;
  }

  async linkEmployeesToLocation(locationCompanyId, employees) {
    for (const employee of employees) {
      await this.contactsApi.updateContact(employee.email, {
        attributes: {
          company_id: locationCompanyId,
          employee_level: employee.level,
          department: employee.department,
          location_rewards_eligible: true
        }
      });
    }
  }

  async consolidateLocationSpending(parentCompanyId) {
    const locations = await this.getCompanyLocations(parentCompanyId);
    let totalSpending = 0;
    let totalRewards = 0;

    for (const location of locations) {
      const locationSpend = location.attributes.annual_spend || 0;
      const locationRewards = location.attributes.loyalty_points || 0;

      totalSpending += locationSpend;
      totalRewards += locationRewards;
    }

    // Update parent company totals
    await this.companiesApi.updateCompany(parentCompanyId, {
      attributes: {
        consolidated_annual_spend: totalSpending,
        consolidated_loyalty_points: totalRewards,
        last_consolidation_date: new Date().toISOString()
      }
    });

    // Check for corporate tier upgrades based on consolidated spending
    await this.tierManager.evaluateTierUpgrade(parentCompanyId, totalSpending);

    return {
      totalSpending,
      totalRewards,
      locationCount: locations.length
    };
  }
}
```

## 기업 거래와 계약

### 거래 관리

로열티에 영향을 주는 기업 거래를 추적하고 관리합니다.

```javascript
class CorporateDealManager {
  async createCorporateDeal(dealData) {
    const deal = {
      name: dealData.dealName,
      company_id: dealData.companyId,
      attributes: {
        deal_value: dealData.value,
        deal_stage: dealData.stage,
        close_date: dealData.expectedCloseDate,
        probability: dealData.probability,
        deal_type: dealData.type, // 'new_business', 'renewal', 'upsell', 'expansion'

        // Loyalty Program Impact
        loyalty_points_included: dealData.loyaltyPointsBonus,
        tier_upgrade_eligible: dealData.tierUpgradeEligible,
        volume_discount_rate: dealData.volumeDiscountRate,

        // Contract Terms
        contract_length: dealData.contractLength,
        renewal_terms: dealData.renewalTerms,
        early_termination_clause: dealData.earlyTermination,

        // Team Assignment
        sales_rep: dealData.salesRep,
        solution_engineer: dealData.solutionEngineer,
        success_manager: dealData.successManager
      }
    };

    const createdDeal = await this.dealsApi.createDeal(deal);

    // Set up deal-specific loyalty tracking
    if (dealData.loyaltyPointsBonus > 0) {
      await this.setupDealLoyaltyTracking(createdDeal.id, dealData);
    }

    return createdDeal;
  }

  async setupDealLoyaltyTracking(dealId, dealData) {
    // Create loyalty milestone based on deal closure
    await loyaltyService.createMilestone({
      companyId: dealData.companyId,
      dealId: dealId,
      type: 'deal_closure',
      pointsReward: dealData.loyaltyPointsBonus,
      tierBonus: dealData.tierUpgradeEligible,
      triggerCondition: 'deal_won'
    });

    // Set up volume discount tracking
    if (dealData.volumeDiscountRate > 0) {
      await loyaltyService.setupVolumeTracking({
        companyId: dealData.companyId,
        dealId: dealId,
        discountRate: dealData.volumeDiscountRate,
        thresholds: this.calculateVolumeThresholds(dealData.value)
      });
    }
  }

  async processDealClosure(dealId, status) {
    const deal = await this.dealsApi.getDeal(dealId);

    if (status === 'won') {
      // Award loyalty points for successful deal
      if (deal.attributes.loyalty_points_included > 0) {
        await loyaltyService.awardCorporatePoints(
          deal.company_id,
          deal.attributes.loyalty_points_included,
          {
            reason: 'Deal closure bonus',
            dealId: dealId,
            dealValue: deal.attributes.deal_value
          }
        );
      }

      // Trigger tier evaluation
      if (deal.attributes.tier_upgrade_eligible) {
        const company = await this.companiesApi.getCompany(deal.company_id);
        const newSpendTotal = (company.attributes.annual_spend || 0) + deal.attributes.deal_value;

        await this.tierManager.evaluateTierUpgrade(deal.company_id, newSpendTotal);
      }

      // Set up renewal tracking
      await this.setupRenewalTracking(deal);
    }

    // Update deal status
    await this.dealsApi.updateDeal(dealId, {
      attributes: {
        deal_stage: status,
        close_date: new Date().toISOString(),
        actual_value: deal.attributes.deal_value
      }
    });
  }
}
```

## 기업 애널리틱스와 리포팅

### 엔터프라이즈 대시보드

기업 계정을 위한 종합 애널리틱스를 구성합니다.

```javascript
class CorporateAnalytics {
  async generateCorporateReport(companyId, timeframe) {
    const company = await this.companiesApi.getCompany(companyId);
    const locations = await this.getCompanyLocations(companyId);
    const deals = await this.getCompanyDeals(companyId, timeframe);
    const contacts = await this.getCompanyContacts(companyId);

    const report = {
      company: {
        name: company.name,
        tier: company.attributes.loyalty_tier,
        totalSpending: company.attributes.annual_spend,
        totalPoints: company.attributes.loyalty_points,
        locations: locations.length
      },

      performance: {
        spendingGrowth: await this.calculateSpendingGrowth(companyId, timeframe),
        tierProgress: await this.calculateTierProgress(companyId),
        loyaltyEngagement: await this.calculateLoyaltyEngagement(companyId),
        volumeDiscountsSaved: await this.calculateVolumeDiscounts(companyId, timeframe)
      },

      deals: {
        totalDeals: deals.length,
        totalValue: deals.reduce((sum, deal) => sum + (deal.attributes.deal_value || 0), 0),
        averageDealSize: deals.length > 0 ? deals.reduce((sum, deal) => sum + (deal.attributes.deal_value || 0), 0) / deals.length : 0,
        winRate: deals.filter(d => d.attributes.deal_stage === 'won').length / deals.length * 100
      },

      engagement: {
        activeContacts: contacts.filter(c => c.attributes.last_activity > this.getDateDaysAgo(30)).length,
        totalContacts: contacts.length,
        emailEngagement: await this.calculateEmailEngagement(contacts),
        rewardRedemptions: await this.getRewardRedemptions(companyId, timeframe)
      },

      recommendations: await this.generateRecommendations(companyId, {
        spending: company.attributes.annual_spend,
        tier: company.attributes.loyalty_tier,
        engagement: await this.calculateLoyaltyEngagement(companyId)
      })
    };

    return report;
  }

  async generateRecommendations(companyId, metrics) {
    const recommendations = [];
    const company = await this.companiesApi.getCompany(companyId);

    // Tier upgrade opportunities
    const nextTier = this.getNextTier(metrics.tier);
    if (nextTier) {
      const spendingNeeded = this.getSpendingForTier(nextTier) - metrics.spending;
      if (spendingNeeded > 0 && spendingNeeded < metrics.spending * 0.5) {
        recommendations.push({
          type: 'tier_upgrade_opportunity',
          title: `${nextTier} tier within reach`,
          description: `Increase annual spending by $${spendingNeeded.toLocaleString()} to unlock ${nextTier} benefits`,
          priority: 'high',
          potentialValue: this.calculateTierUpgradeValue(nextTier)
        });
      }
    }

    // Volume discount opportunities
    if (metrics.spending > 100000 && !company.attributes.volume_discount_enrolled) {
      recommendations.push({
        type: 'volume_discount',
        title: 'Volume discount eligible',
        description: 'Enroll in volume discount program to save up to 15% on bulk orders',
        priority: 'medium',
        potentialSavings: metrics.spending * 0.15
      });
    }

    // Engagement improvement
    if (metrics.engagement < 0.5) {
      recommendations.push({
        type: 'engagement_improvement',
        title: 'Boost employee engagement',
        description: 'Consider employee loyalty workshops or gamification features',
        priority: 'medium',
        expectedImpact: 'Increase program utilization by 30%'
      });
    }

    return recommendations;
  }
}
```

## API 메서드 레퍼런스

### Companies CRUD 작업

```javascript
// Get company details
const company = await companiesApi.getCompany('comp_123456789');

// Update company attributes
await companiesApi.updateCompany('comp_123456789', {
  attributes: {
    annual_spend: 750000,
    loyalty_tier: 'Enterprise Platinum',
    last_tier_review: new Date().toISOString()
  }
});

// Delete company (removes all associated data)
await companiesApi.deleteCompany('comp_123456789');

// Get all companies with filtering
const companies = await companiesApi.getCompanies({
  filters: {
    'attributes.loyalty_tier': 'Enterprise Gold',
    'attributes.annual_spend': '>500000'
  },
  sort: 'attributes.annual_spend:desc',
  limit: 50
});
```

### 고급 쿼리

```javascript
// Find companies by industry and tier
const techGoldCompanies = await companiesApi.getCompanies({
  filters: {
    'attributes.industry': 'Technology',
    'attributes.loyalty_tier': 'Enterprise Gold',
    'attributes.contract_value': '>250000'
  }
});

// Get companies due for renewal
const renewalDueCompanies = await companiesApi.getCompanies({
  filters: {
    'attributes.renewal_date': `<${new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toISOString()}`
  }
});

// Find high-value inactive companies
const inactiveHighValueCompanies = await companiesApi.getCompanies({
  filters: {
    'attributes.annual_spend': '>500000',
    'attributes.last_activity': `<${new Date(Date.now() - 60 * 24 * 60 * 60 * 1000).toISOString()}`
  }
});
```

## 권장 사례

1. **계층 구조**: 다지점 회사에는 상위-하위 관계를 사용합니다
2. **통합 리포팅**: 모든 지점의 지출과 리워드를 합산합니다
3. **등급 관리**: 통합 지출액을 기준으로 등급을 정기적으로 재평가합니다
4. **어카운트 팀 연계**: 로열티 프로그램 변경 사항을 어카운트 매니저에게 계속 공유합니다
5. **커스텀 속성**: 업종별 데이터를 담을 수 있도록 속성을 폭넓게 활용합니다
6. **자동화된 워크플로**: 등급 상향과 계약 갱신에 대한 트리거를 설정합니다

## 오류 처리

```javascript
try {
  const company = await companiesApi.createCompany(companyData);
  console.log('Company created:', company.id);
} catch (error) {
  if (error.status === 409) {
    console.error('Company already exists with this name');
  } else if (error.status === 400) {
    console.error('Invalid company data:', error.message);
  } else {
    console.error('Unexpected error:', error);
  }
}
```

## 다음 단계

- **[거래 관리](https://tajo.io/kr/docs/sales-crm/deals)** - 기업 거래와 영업 기회를 추적합니다
- **[업무 관리](https://tajo.io/kr/docs/sales-crm/tasks)** - 계정 관련 활동과 후속 조치를 관리합니다
- **[노트와 파일](https://tajo.io/kr/docs/sales-crm/notes)** - 고객 상호작용을 기록합니다
- **CRM 애널리틱스** - 고급 리포팅과 인사이트