---
title: "Gestion des entreprises"
description: "Gérez les entreprises B2B et les comptes d’entreprise dans le CRM Brevo pour les programmes de fidélité entreprise de Tajo"
url: https://tajo.io/fr/docs/sales-crm/companies/
markdown: https://tajo.io/fr/docs/sales-crm/companies.md
lang: fr-FR
robots: noindex
---

Demandez un accès anticipé

Indiquez votre prénom et votre adresse e-mail professionnelle. Nous vous enverrons un lien pour confirmer votre demande d’accès à Tajo.

# Gestion des entreprises

L’API Companies du CRM Brevo vous permet de gérer les relations B2B et les comptes d’entreprise associés aux programmes de fidélité entreprise au sein de la plateforme Tajo.

## Vue d’ensemble

La gestion des entreprises est essentielle pour :

- **Programmes de fidélité entreprise** avec récompenses groupées et gestion des niveaux
- **Relations clients B2B** avec des gestionnaires de compte dédiés
- **Suivi des ventes entreprise** avec des analyses au niveau de l’entreprise
- **Entreprises multisites** avec une gestion centralisée de la fidélité
- **Programmes partenaires et revendeurs** avec une tarification et des récompenses spécifiques

## Démarrage rapide

### Créer une entreprise

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

### Réponse

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

## Intégration de la fidélité entreprise

### Configuration d’un compte d’entreprise

Configurez des comptes d’entreprise complets, intégrés au programme de fidélité :

```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
    });
  }
}
```

### Gestion des niveaux entreprise

Mettez en place une gestion fine des niveaux pour les comptes 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';
  }
}
```

## Gestion multisite

### Hiérarchie des sites

Gérez des structures d’entreprise multisites complexes :

```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
    };
  }
}
```

## Transactions et contrats entreprise

### Gestion des transactions

Suivez et gérez les transactions entreprise et leurs implications sur la fidélité :

```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
      }
    });
  }
}
```

## Analyse et reporting entreprise

### Tableau de bord entreprise

Créez des analyses complètes pour les comptes d’entreprise :

```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;
  }
}
```

## Référence des méthodes de l’API

### Opérations CRUD sur les entreprises

```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
});
```

### Requêtes avancées

```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()}`
  }
});
```

## Bonnes pratiques

1. **Structure hiérarchique** : utilisez des relations parent-enfant pour les entreprises multisites
2. **Reporting consolidé** : agrégez les dépenses et les récompenses de tous les sites
3. **Gestion des niveaux** : évaluez régulièrement les niveaux à partir des dépenses consolidées
4. **Intégration de l’équipe de compte** : tenez les gestionnaires de compte informés des changements du programme de fidélité
5. **Attributs personnalisés** : utilisez des attributs complets pour les données propres à chaque secteur
6. **Workflows automatisés** : mettez en place des déclencheurs pour les montées en niveau et les renouvellements de contrat

## Gestion des erreurs

```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);
  }
}
```

## Prochaines étapes

- **[Gestion des transactions](https://tajo.io/fr/docs/sales-crm/deals)** - Suivez les transactions et les opportunités entreprise
- **[Gestion des tâches](https://tajo.io/fr/docs/sales-crm/tasks)** - Gérez les activités et les relances liées aux comptes
- **[Notes et fichiers](https://tajo.io/fr/docs/sales-crm/notes)** - Documentez les interactions clients
- **Analyse du CRM** - Rapports et analyses avancés