Gong API : Guide développeur complet [2026]

L’API Gong est une interface RESTful qui offre aux développeurs un accès programmatique à la plateforme d’intelligence conversationnelle de Gong.
Elle permet d’extraire des enregistrements d’appels, des transcriptions, des statistiques utilisateurs, des données CRM — ou encore d’automatiser des workflows d’outbound et des séquences d’engagement.

Là où cela devient confus : Gong propose en réalité deux API distinctes, et comprendre la différence est essentiel pour votre intégration.
‍

Qu'est-ce que l'API de Gong? Différences entre Standard API vs Engage API

La majorité des développeurs qui recherchent “Gong API” ont besoin de la Standard (Core) API, utilisée pour extraire les données d’appels et construire des intégrations.

L’Engage API, elle, est spécialisée pour les équipes utilisant les fonctionnalités d’automatisation d’outreach de Gong.

Quelles données peut-on récupérer ?

Avec la Standard API, vous pouvez extraire :

• les enregistrements et transcriptions d’appels complets
• les métriques d’activité utilisateur et statistiques d’engagement
• les scorecards personnalisés et données d’évaluation
• les mappings CRM et l’état des synchronisations
• les analyses de performance d’équipe

Ces données permettent d’alimenter des dashboards personnalisés, des workflows d’enrichissement CRM, ou encore des automatisations internes.

La prochaine section explique comment obtenir l’accès API.
‍

Obtenir l’accès API : prérequis et génération des identifiants

Avant d’écrire la moindre ligne de code, un point crucial :

👉 Vous devez être administrateur Gong pour générer les identifiants API.
Si vous ne l’êtes pas, vous devrez demander l’accès à quelqu’un qui possède ce rôle.
C’est une règle stricte : impossible de la contourner via les permissions.

Comment un administrateur récupère les identifiants API ?

1. Se connecter à Gong avec un compte administrateur
2. Aller dans Settings → API
3. Cliquer sur “Get API Key”
4. Sauvegarder immédiatement la clé d’accès et la clé secrète — la clé secrète ne sera plus affichée

Gong utilise une authentification basée sur une API Key, ce qui implique d’inclure vos identifiants dans l’en-tête de chaque requête.

Securiser vos identifiants

Ne jamais hardcoder vos API keys dans le code source. Utilisez plutôt des variables d’environnement, par exemple :

import os
from dotenv import load_dotenv

load_dotenv()

GONG_ACCESS_KEY = os.getenv('GONG_ACCESS_KEY')
GONG_ACCESS_SECRET = os.getenv('GONG_ACCESS_SECRET')

Stocker les identifiants dans un fichie .env (et l'ajouter au .gitignore):

GONG_ACCESS_KEY=your_access_key_here
GONG_ACCESS_SECRET=your_secret_here

Bonnes pratiques de sécurité :

• Rotation des identifiants tous les 90 jours
• Utilisation d’outils de gestion de secrets en production
  (AWS Secrets Manager, HashiCorp Vault, etc.)
• Limiter l’accès à l’API à certaines plages d’adresses IP lorsque c’est possible
• Ne jamais committer les identifiants dans le contrôle de version
• Auditer régulièrement les logs d’utilisation de l’API

Une fois vos identifiants sécurisés, vous êtes prêt à effectuer votre premier appel API.
‍

Comprendre les endpoints del'API de Gong

Maintenant que vous avez vos identifiants, cartographions la structure de l’API pour comprendre quel endpoint fait quoi.

L’API Gong organise ses endpoints par catégories logiques, chacune correspondant à un besoin d’accès aux données.
L’URL de base pour toutes les requêtes est : https://api.gong.io/v2/


La plupart des endpoints respectent les conventions REST.

Catégories d’endpoints API

Chaque endpoint renvoie des réponses JSON avec une structure cohérente.
Les listes sont paginées par défaut, et la majorité des endpoints acceptent des paramètres de filtrage : plages de dates, ID utilisateurs, résultats d’appel

Aperçu des limites de taux (Rate Limits)

Gong applique des rate limits pour protéger la stabilité de la plateforme.

Nous détaillerons cela plus loin, mais en général, vous pouvez vous attendre à des limites autour de 1 000 requêtes par heure pour la plupart des endpoints.

Les réponses API contiennent des en-têtes dédiés aux limites de taux, il est recommandé de les surveiller.

Documentation complète

Les documents officiels disponibles sur help.gong.io/docs incluent :

• Spécifications complètes de chaque endpoint
• Schémas de requêtes / réponses
• Options de filtres
• Types d’événements Webhook

Ajoutez cette URL en favori : vous l’utiliserez tout au long de votre implémentation.
‍

Votre premier appel à Gong API : Tutoriel Python

Maintenant que la structure est claire, passons au concret.
Voici comment réaliser votre premier appel API pour récupérer des appels récents.

Faire une requête GET : récupérer les données d’appel

Voici un exemple complet qui s’authentifie et récupère des données d’appels :

import requests
import base64
import os
from dotenv import load_dotenv
from datetime import datetime, timedelta

# Load credentials from environment
load_dotenv()
ACCESS_KEY = os.getenv('GONG_ACCESS_KEY')
ACCESS_SECRET = os.getenv('GONG_ACCESS_SECRET')

# Set up authentication
credentials = f"{ACCESS_KEY}:{ACCESS_SECRET}"
encoded_credentials = base64.b64encode(credentials.encode()).decode()

headers = {
    "Authorization": f"Basic {encoded_credentials}",
    "Content-Type": "application/json"
}

# Define API endpoint and parameters
BASE_URL = "https://api.gong.io/v2"
endpoint = f"{BASE_URL}/calls"

# Get calls from the last 7 days
from_date = (datetime.now() - timedelta(days=7)).isoformat()
to_date = datetime.now().isoformat()

params = {
    "fromDateTime": from_date,
    "toDateTime": to_date
}

# Make the request
response = requests.get(endpoint, headers=headers, params=params)

# Handle the response
if response.status_code == 200:
    calls_data = response.json()
    print(f"Retrieved {len(calls_data['calls'])} calls")
    
    # Process each call
    for call in calls_data['calls']:
        print(f"Call ID: {call['id']}")
        print(f"Duration: {call['duration']} seconds")
        print(f"Participants: {', '.join([p['emailAddress'] for p in call['parties']])}")
        print("---")
else:
    print(f"Error: {response.status_code}")
    print(response.text)

Ce qui se passe dans cet exemple :

• Chargement des identifiants depuis les variables d’environnement (ne jamais les écrire en dur)
• Encodage des identifiants en Base64 pour l’authentification Basic Auth
• Définition des headers (authentification + type de contenu)
• Construction de l’URL de l’endpoint API
• Définition des paramètres de requête (plages de dates, filtres…)
• Exécution de la requête GET via requests
• Parsing de la réponse JSON et extraction des informations utiles

La réponse contient :

• les métadonnées de l’appel
• les participants
• la durée
• les IDs nécessaires pour récupérer le transcript

Faire une requête POST : créer ou mettre à jour des données

Les requêtes POST fonctionnent de manière similaire, mais incluent un corps JSON. Exemple : mise à jour de données CRM via l’API.

import requests
import json

# Same authentication setup as above
headers = {
    "Authorization": f"Basic {encoded_credentials}",
    "Content-Type": "application/json"
}

# CRM update endpoint
endpoint = f"{BASE_URL}/crm/object"

# Define the payload
payload = {
    "objectType": "Opportunity",
    "objectId": "12345",
    "fields": {
        "stage": "Negotiation",
        "amount": 50000,
        "closeDate": "2025-12-31"
    }
}

# Make POST request
response = requests.post(
    endpoint,
    headers=headers,
    data=json.dumps(payload)
)

if response.status_code == 200:
    print("CRM updated successfully")
    print(response.json())
else:
    print(f"Error: {response.status_code}")
    print(response.text)

Différences clés pour une requête POST :

• Utiliser requests.post() au lieu de requests.get()
• Inclure un payload JSON dans data=
• Ajouter l’en-tête Content-Type: application/json
• Vérifier la réponse pour s’assurer que la mise à jour a bien fonctionné

Avec les schémas GET et POST maîtrisés, vous pouvez interagir avec n’importe quel endpoint du Gong API.
‍

Cas d’usage courants de l’API Gong et schémas d’implémentation

Voyons trois cas d’usage à fort impact qui montrent comment les équipes utilisent réellement l’API Gong en production.

Cas d’usage 1 : Extraire les transcriptions d’appels pour analyse

Valeur business : alimenter des modèles NLP personnalisés, des outils d’analyse de sentiment ou des data warehouses pour l’analyse de tendances.

Schéma d’implémentation :

def get_call_transcript(call_id):
    """Fetch full transcript for a specific call"""
    endpoint = f"{BASE_URL}/calls/{call_id}/transcript"
    
    response = requests.get(endpoint, headers=headers)
    
    if response.status_code == 200:
        transcript_data = response.json()
        
        # Extract speaker turns
        full_transcript = []
        for sentence in transcript_data['transcript']:
            speaker = sentence['speakerId']
            text = sentence['text']
            timestamp = sentence['start']
            
            full_transcript.append({
                'speaker': speaker,
                'text': text,
                'timestamp': timestamp
            })
        
        return full_transcript
    else:
        raise Exception(f"Failed to fetch transcript: {response.status_code}")

# Usage with pagination for bulk extraction
def extract_all_transcripts(from_date, to_date):
    """Extract transcripts for all calls in date range"""
    calls = get_all_calls(from_date, to_date)
    
    transcripts = {}
    for call in calls:
        call_id = call['id']
        try:
            transcript = get_call_transcript(call_id)
            transcripts[call_id] = transcript
            print(f"Extracted transcript for call {call_id}")
        except Exception as e:
            print(f"Error with call {call_id}: {e}")
    
    return transcripts

‍Points d’attention :

• Les transcriptions peuvent être volumineuses — gérer la pagination et les limites de débit.
• Stocker les transcriptions dans une base de données plutôt que de les récupérer à chaque fois.
• Gérer les erreurs pour les appels sans transcription (problèmes techniques, appels très récents).

Cas d’usage 2 : Synchronisation bidirectionnelle avec le CRM

Valeur business : maintenir Salesforce ou HubSpot automatiquement à jour avec les résultats d’appel, les next steps et les insights deal — sans saisie manuelle.

Schéma d’implémentation :

def sync_call_to_crm(call_id, crm_opportunity_id):
    """Extract call insights and push to CRM"""
    
    # Get call details
    call_data = requests.get(
        f"{BASE_URL}/calls/{call_id}",
        headers=headers
    ).json()
    
    # Extract relevant fields
    call_outcome = call_data.get('outcome', 'Unknown')
    next_steps = call_data.get('nextSteps', '')
    participants = [p['emailAddress'] for p in call_data['parties']]
    
    # Update CRM opportunity
    crm_payload = {
        "objectType": "Opportunity",
        "objectId": crm_opportunity_id,
        "fields": {
            "last_call_date": call_data['started'],
            "last_call_outcome": call_outcome,
            "next_steps": next_steps,
            "gong_call_id": call_id
        }
    }
    
    response = requests.post(
        f"{BASE_URL}/crm/object",
        headers=headers,
        json=crm_payload
    )
    
    return response.status_code == 200

Bonnes pratiques CRM :

• Mapper les champs Gong aux champs CRM de manière cohérente.
• Exécuter des jobs de synchronisation incrémentale (seulement nouveaux / modifiés) pour éviter de dépasser les limites API.
• Stocker la correspondance entre les IDs d’appels Gong et les IDs d’opportunités CRM.
• Gérer les cas où les enregistrements CRM n’existent pas encore.

Cas d’usage 3 : Reporting personnalisé & dashboards analytiques

Valeur business : construire des dashboards exécutifs combinant données de conversations, pipeline, atteinte des quotas et performance des équipes.

Schéma d’implémentation :

def generate_team_performance_report(team_id, from_date, to_date):
    """Aggregate multiple endpoints for comprehensive team report"""
    
    # Get team members
    team_response = requests.get(
        f"{BASE_URL}/users",
        headers=headers,
        params={"teamId": team_id}
    )
    team_members = team_response.json()['users']
    
    # Collect stats for each member
    team_report = []
    
    for member in team_members:
        user_id = member['id']
        
        # Get call volume
        calls = requests.get(
            f"{BASE_URL}/calls",
            headers=headers,
            params={
                "fromDateTime": from_date,
                "toDateTime": to_date,
                "userId": user_id
            }
        ).json()
        
        # Get interaction stats
        stats = requests.get(
            f"{BASE_URL}/users/{user_id}/stats",
            headers=headers,
            params={
                "fromDate": from_date,
                "toDate": to_date
            }
        ).json()
        
        team_report.append({
            'user': member['emailAddress'],
            'total_calls': len(calls.get('calls', [])),
            'talk_ratio': stats.get('talkToListenRatio', 0),
            'avg_call_duration': stats.get('averageCallDuration', 0),
            'questions_asked': stats.get('questionsAsked', 0)
        })
    
    return team_report

# Export to CSV for dashboard tools
import csv

def export_report_to_csv(report_data, filename):
    """Export report data to CSV for Tableau/Looker/etc"""
    
    with open(filename, 'w', newline='') as csvfile:
        if not report_data:
            return
        
        fieldnames = report_data[0].keys()
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        
        writer.writeheader()
        for row in report_data:
            writer.writerow(row)

Conseils analytics :

• Combiner plusieurs endpoints pour une vue complète (appels + stats + données CRM).
• Mettre en cache les données relativement statiques (structures d’équipes, profils utilisateurs) pour réduire les appels API.
• Programmer la génération de rapports en heures creuses.
• Exporter dans des formats compatibles BI (CSV, Parquet, JSON).

Rate Limits, gestion des erreurs et bonnes pratiques

Avec ces cas d’usage en tête, passons aux garde-fous techniques.

Comprendre les limites de débit

Gong applique des rate limits pour maintenir la stabilité de la plateforme :

• Limite standard : 1 000 requêtes par heure et par clé API
• Burst allowance : les pics ponctuels sont tolérés, pas les volumes soutenus
• Les réponses renvoient :
  X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset

Quand la limite est atteinte → erreur 429 Too Many Requests. Il faut alors appliquer une logique de retry avec backoff exponentiel, jamais ignorer.

import time
import requests

def gong_api_call_with_retry(url, headers, max_retries=3):
    for attempt in range(max_retries):
        response = requests.get(url, headers=headers)
        
        if response.status_code == 200:
            return response.json()
        
        elif response.status_code == 429:
            # Rate limit hit—exponential backoff
            wait_time = (2 ** attempt) * 5  # 5s, 10s, 20s
            print(f"Rate limited. Retrying in {wait_time}s...")
            time.sleep(wait_time)
        
        elif response.status_code == 401:
            raise Exception("Authentication failed. Check your API credentials.")
        
        elif response.status_code == 400:
            raise Exception(f"Bad request: {response.json()}")
        
        elif response.status_code >= 500:
            # Server error—retry with backoff
            wait_time = (2 ** attempt) * 3
            print(f"Server error. Retrying in {wait_time}s...")
            time.sleep(wait_time)
        
        else:
            raise Exception(f"Unexpected error: {response.status_code}")
    
    raise Exception("Max retries exceeded")

Gestion des erreurs

Stratégies d'optimisation

Réduisez les appels API et améliorez la performance en appliquant ces stratégies :

1. Batch requests si possible

Évitez de récupérer les appels un par un. Utilisez les endpoints batch ou les filtres par plages.

# ❌ Inefficient
for call_id in call_ids:
    call_data = get_call(call_id)

2. Synchronisation incrémentale

Ne rechargez pas toutes les données à chaque exécution. Utilisez des timestamps pour ne récupérer que les nouveaux événements.

last_sync = get_last_sync_timestamp()
new_calls = get_calls(from_datetime=last_sync)

3. Cache pour les données statiques

Profils utilisateurs, organigrammes, mapping CRM. Rafraîchir toutes les 24 h au lieu de chaque requête.

4. Gérer correctement la pagination

Les endpoints de liste sont paginés. Implémenter la pagination pour ne rien manquer.

def get_all_calls(from_date, to_date):
    all_calls = []
    cursor = None
    
    while True:
        response = requests.get(
            f"{BASE_URL}/calls",
            headers=headers,
            params={
                "fromDateTime": from_date,
                "toDateTime": to_date,
                "cursor": cursor
            }
        )
        
        data = response.json()
        all_calls.extend(data['calls'])
        
        # Check if more pages exist
        cursor = data.get('records', {}).get('cursor')
        if not cursor:
            break
    
    return all_calls

‍

Données personnelles, sécurité & conformité RGPD

Vous manipulez des données sensibles de conversations : la conformité n’est pas optionnelle.

Consentement d’enregistrement (RGPD)

Si vous extrayez enregistrements ou transcriptions :

• UE / UK : consentement explicite obligatoire pour toutes les parties
• US : lois variables, des États exigent la double-consentement
• Australie : consentement requis sauf exceptions business

Lors de l’extraction via API :

• Vérifier que le consentement a été obtenu
• Inclure le statut de consentement dans le data warehouse
• Aligner vos durées de conservation sur celles configurées dans Gong

DSAR (Demandes d’accès ou suppression)

Si vous stockez les données Gong :

• Maintenir les correspondances entre IDs d’appel et identités des participants
• Pouvoir supprimer rapidement toutes les données correspondant à un individu
• Documenter vos flux pour les audits

Gestion des données personnelles (PII) dans les transcriptions

Les transcriptions peuvent contenir :

• Emails
• Téléphones
• Informations de compte

Bonnes pratiques :

• Évaluer si vous devez vraiment stocker la transcription complète
• Préférer les résumés ou entités extraites si possible (moins risqué)

import re

def redact_pii_from_transcript(transcript):
    # Redact email addresses
    transcript = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '[EMAIL]', transcript)
    
    # Redact phone numbers (US format example)
    transcript = re.sub(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[PHONE]', transcript)
    
    # Redact credit card numbers
    transcript = re.sub(r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b', '[CARD]', transcript)
    
    return transcript

Sécurité technique

Transport

• Toujours utiliser HTTPS/TLS
• Ne jamais désactiver la validation des certificats en production

Gestion des clés secrètes

• Utiliser AWS Secrets Manager / Azure Key Vault / HashiCorp Vault
• Rotation trimestrielle minimum
• Une clé par environnement (dev / staging / prod)

Contrôle d’accès

• Accès restreint aux clés API
• Utiliser des comptes de service, pas des comptes admin personnels
• Audit mensuel des logs API

Checklist de conformité avant mise en production

• Consentement d’enregistrement activé
• Politique de rétention documentée
• Process DSAR opérationnel
• Redaction PII si nécessaire
• Encryption des données au repos
• Logging & monitoring actifs
• Conformité aux politiques internes
• Formation des équipes au traitement de données

Stockage des données

Gong stocke les données dans des régions spécifiques :

• Vérifier la région associée à votre instance (US, UE…)
• S’assurer que votre stockage externe est conforme (RGPD, clauses SCC)

Les transferts transfrontaliers doivent respecter les exigences légales.
‍

Rester à jour : documentation, changelog et support

Les API évoluent, et celle de Gong ne fait pas exception — voici comment rester informé des changements susceptibles d’affecter votre intégration.

Documentation officielle

La référence complète pour tout ce qui concerne l’API Gong se trouve sur help.gong.io/docs. Vous y trouverez :

• La documentation API complète avec tous les endpoints et paramètres
• Les guides d’authentification et bonnes pratiques de sécurité
• La documentation Webhooks pour les intégrations événementielles
• Des exemples de code dans plusieurs langages

Ajoutez-la à vos favoris. Mieux encore : ouvrez-la automatiquement quand vous débugguez.

Changelog et mises à jour de l’API

Gong publie les changements API via plusieurs canaux :

• Emplacement du changelog : section “What’s New” de la documentation API
• Fréquence : les changements majeurs sont annoncés au moins 30 jours à l’avance
• Breaking changes : Gong maintient la compatibilité autant que possible, mais des changements non rétro-compatibles peuvent survenir — généralement lors d’un changement de version

Abonnez-vous aux notifications si disponible, ou consultez le changelog une fois par mois dans le cadre de votre maintenance.

Collection Postman pour les tests

La collection Postman de l’API Gong fournit des requêtes préconfigurées pour les endpoints principaux.
Vous la trouverez ici :
postman.com/growment/gong-meetup/collection/yuikwaq/gong-api-beginners-guide

Elle inclut :

• Des requêtes exemples pour chaque catégorie d’endpoint
• Des templates d’authentification préremplis
• Des réponses types pour comprendre les structures de données
• Des workflows correspondant aux cas d’usage courants

Importez la collection, ajoutez vos identifiants API, et vous obtenez un environnement de test interactif en quelques minutes.

Communauté développeurs et support

En cas de blocage, voici vos meilleurs alliés :

• Forums Gong Community : visioneers.gong.io — discussions et solutions entre développeurs
• Support officiel : formulaire d’assistance sur help.gong.io
• GitHub : certains membres publient des SDKs non officiels — recherchez “gong api”

Surveiller les dépréciations

Les API déprécient parfois certains endpoints. Restez vigilant :

• Repérez les avertissements de dépréciation dans les réponses API (headers)
• Consultez le changelog chaque trimestre pour détecter les annonces “deprecated” ou “sunset”
• Testez votre intégration avec les nouvelles versions en staging avant mise à jour production

Votre intégration n’est jamais “terminée”. Prévoir du temps pour la maintenance continue est essentiel.
‍

Approche alternative : le MCP et l'API de Claap pour la Conversation Intelligence

Alors que l’API Gong nécessite un accès administrateur et un travail d’intégration sur mesure, certaines équipes optent pour des solutions plus simples. Claap propose deux approches distinctes :

• Une API REST classique
• Une intégration MCP (Model Context Protocol) pensée pour les usages IA modernes

Claap MCP : l’intégration native IA

Le MCP de Claap permet aux assistants IA (comme Claude) d’accéder directement à vos données de conversation — sans écrire une seule ligne d’API.

Particulièrement utile si vous :

• construisez des agents IA
• utilisez des outils comme Cline, Zed, ou Claude Desktop
• voulez interroger votre bibliothèque de réunions en langage naturel

Ce que permet MCP :

• Requêtes type : “Trouve toutes les conversations mentionnant une objection pricing”
• Extraction d’insights sur plusieurs appels sans gérer pagination, headers, etc.
• Accès aux résumés, transcriptions et actions dans des interfaces IA
• Workflows personnalisés générés par IA

Exemple d’usage :

Utilisateur : “Analyse nos 10 derniers discovery calls et identifie les pains récurrents.”
Claude → récupère les appels via MCP → lit les transcriptions → génère une analyse.

Pas d’entêtes d’authentification. Pas de gestion de rate limit. Pas de parsing JSON. L’IA gère toute la complexité API.

Regardez comment créer un tableau de bord complet des objections de vente en une seule requête grâce au MCP de Claap : Démo d'un tableau de bord interractif

API REST Claap : l’intégration traditionnelle

Pour les équipes préférant les méthodes API classiques, Claap propose aussi une API REST proche de celle de Gong.

Endpoints clés :

• /calls — lister et filtrer les appels
• /calls/{id} — détails d’un appel
• /calls/{id}/transcript — transcription complète
• /insights — résumés et insights générés par l’IA
• /clips — création et gestion de clips vidéo

Authentification : clé API simple (plus facile que le Basic Auth clé+secret de Gong)

import requests

headers = {
    "Authorization": f"Bearer {CLAAP_API_KEY}",
    "Content-Type": "application/json"
}

response = requests.get(
    "https://api.claap.io/v1/calls",
    headers=headers,
    params={"limit": 10}
)

Avantages par rapport à Gong :

• Pas besoin d’être administrateur pour générer une clé API
• Option MCP pour supprimer 90 % du code d’intégration
• Smart Tables API pour analyser plusieurs appels d’un coup
• Webhooks pour traitement en temps réel

Quand utiliser quoi :

-> Vous construisez des agents IA, utilisez Claude/Cline, ou voulez requêter vos meetings en langage naturel : MCP

-> Vous avez besoin d’une intégration CRM, data pipeline ou système backend : REST API

Les deux donnent accès aux mêmes données, seule l’interface change.

Explorez la documentation de l'API de Claap | Plus d'info sur Claap MCP

FAQ

Ai-je besoin d’être administrateur Gong pour accéder à l’API ?

Oui. Seuls les administrateurs peuvent générer des identifiants API.
Si vous n’êtes pas admin, vous devrez en demander l’accès.

Différence entre Gong Standard API et Gong Engage API ?

• Standard API : données de conversation (appels, transcripts, stats, CRM sync).
• Engage API : gestion des séquences d’outbound automatisées.

La plupart des développeurs ont uniquement besoin de la Standard API.

Comment récupérer ma clé API Gong ?

Admin Gong → Settings → API → “Get API Key”
Note : vous ne verrez le secret qu’une seule fois. Si vous le perdez → recréez un couple clé/secret.

Quel est le rate limit ?

Environ 1 000 requêtes / heure / clé API.
En cas de dépassement → réponse 429 Too Many Requests.

Puis-je extraire les enregistrements et transcriptions ?

Oui, via /calls/{id}/transcript et les endpoints liés aux enregistrements.
Mais attention : cela implique des responsabilités GDPR, consentement, PII, etc.

Comment s’authentifier ?

Gong utilise Basic Auth avec clé + secret encodés en base64.

import base64

credentials = f"{ACCESS_KEY}:{ACCESS_SECRET}"
encoded = base64.b64encode(credentials.encode()).decode()
headers = {
    "Authorization": f"Basic {encoded}",
    "Content-Type": "application/json"
}

Every request must include this header. Never send credentials in URL parameters or request bodies.

Quelles obligations GDPR ?

• Vérifier le consentement d’enregistrement
• Gérer les demandes DSAR
• Mettre en place des politiques de rétention
• Chiffrer et protéger les données extraites

Existe-t-il une collection Postman ?

Oui : “Gong API - Beginners Guide” est disponible sur Postman : postman.com/growment/gong-meetup. Elle inclut des requêtes exemples pour tous les principaux endpoints, avec des modèles d’authentification préconfigurés. Importez-la, ajoutez vos identifiants, et vous disposez immédiatement d’un environnement de test interactif.

‍

Vous cherchez une alternative à Gong? Testez Claap

Claap est la meilleure alternative à Gong pour la revenue intelligence.
La plateforme offre des fonctionnalités puissantes : enregistrement des meetings, résumés IA, tâches automatiques (mises à jour CRM, emails de follow-up), insights par interlocuteur et par deal, coaching commercial… le tout à un tarif beaucoup plus accessible.

En plus, Claap est nettement plus abordable que Gong.
Nous avons rédigé un article détaillant le prix de Gong ainsi qu’une comparaison complète Gong vs. Claap pour vous aider à choisir la meilleure solution pour votre équipe Sales.

Vous pouvez même remplacer des outils comme Loom grâce à l’enregistreur d’écran intégré de Claap, qui permet d’envoyer des vidéos rapides à votre équipe ou à vos prospects, éditables en quelques secondes et connectées à vos outils du quotidien (Notion, HubSpot, Slack, Linear…). 👉 De vraies économies sur votre stack outils.

Prêt à booster votre équipe commerciale ?

Réservez une démo personnalisée de Claap !
Des entreprises comme Qonto, Revolut, 360Learning et OpenClassrooms ont déjà choisi Claap plutôt que Gong.