CRM-integratie: Salesforce en HubSpot
Klantgeschiedenis ophalen, interacties registreren en CRM-records bijwerken.
CRM-integratie: Salesforce en HubSpot is een gratis AI-agenten-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI-agenten. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI-agenten bevat in totaal 4 lessen.
Waarom CRM-integratie belangrijk is
Een klantenservicemedewerker die de geschiedenis van een klant niet kan zien, werkt blind. CRM-systemen zoals Salesforce en HubSpot bevatten het volledige klantdossier: eerdere tickets, aankopen, abonnementsniveau en accountnotities.
Door met het CRM te integreren kan de medewerker antwoorden personaliseren en problemen sneller oplossen.
Verbinden met Salesforce via simple-salesforce
simple-salesforce is de populairste Python-bibliotheek voor de Salesforce REST API. Maak verbinding met een gebruikersnaam, wachtwoord en beveiligingstoken, of via een OAuth-flow voor een gekoppelde app.
from simple_salesforce import Salesforce
sf = Salesforce(
username='agent@company.com',
password='YOUR_SF_PASSWORD',
security_token='YOUR_SF_TOKEN',
domain='login' # use 'test' for sandbox
)
print('Connected to Salesforce org:', sf.base_url)SOQL-query's: klantgegevens ophalen
Salesforce Object Query Language (SOQL) lijkt op SQL, maar werkt met Salesforce-objecten. Gebruik deze taal om een contactpersoon op e-mailadres op te zoeken en de gegevens van diens account op te halen.
def get_customer_by_email(sf, email: str) -> dict | None:
query = (
f"SELECT Id, FirstName, LastName, Email, AccountId, "
f"Account.Name, Account.Type "
f"FROM Contact "
f"WHERE Email = '{email}' "
f"LIMIT 1"
)
result = sf.query(query)
if result['totalSize'] == 0:
return None
record = result['records'][0]
return {
'contact_id': record['Id'],
'name': f"{record['FirstName']} {record['LastName']}",
'account_id': record['AccountId'],
'account_name': record['Account']['Name']
}
if __name__ == '__main__':
class FakeSF:
def query(self, query):
return {
'totalSize': 1,
'records': [{
'Id': '003ABC', 'FirstName': 'Jane', 'LastName': 'Doe',
'AccountId': '001XYZ',
'Account': {'Name': 'Acme Corp', 'Type': 'Customer'},
}],
}
customer = get_customer_by_email(FakeSF(), 'jane@acme.com')
print(f"Found customer: {customer['name']} at {customer['account_name']}")
Ondersteuningsgeschiedenis uit Salesforce ophalen
Query het object Case om eerdere ondersteuningstickets van de klant op te halen. Neem de status en oplossing van de case op, zodat de medewerker niet twee keer dezelfde vragen hoeft te stellen.
def get_case_history(sf, contact_id: str, limit: int = 10) -> list:
query = (
f"SELECT Id, CaseNumber, Subject, Status, "
f"CreatedDate, ClosedDate, Resolution__c "
f"FROM Case "
f"WHERE ContactId = '{contact_id}' "
f"ORDER BY CreatedDate DESC "
f"LIMIT {limit}"
)
result = sf.query(query)
return [
{
'case_number': r['CaseNumber'],
'subject': r['Subject'],
'status': r['Status'],
'created': r['CreatedDate'][:10],
'resolution': r.get('Resolution__c')
}
for r in result['records']
]
if __name__ == '__main__':
class FakeSF:
def query(self, query):
return {'records': [{
'Id': '500A', 'CaseNumber': '00001234', 'Subject': 'Login issue',
'Status': 'Closed', 'CreatedDate': '2026-07-01T10:00:00Z',
'ClosedDate': '2026-07-02T09:00:00Z', 'Resolution__c': 'Reset password',
}]}
for case in get_case_history(FakeSF(), '003ABC'):
print(f"Case {case['case_number']}: {case['subject']} ({case['status']})")
Een nieuwe Case maken in Salesforce
Wanneer de medewerker vanuit een gesprek een nieuw ondersteuningsticket maakt, voeg je een nieuw Case-record toe. Koppel het aan de contactpersoon en het account, zodat het in de tijdlijn van de klant verschijnt.
def create_case(sf, contact_id: str, account_id: str,
subject: str, description: str, priority: str = 'Medium') -> str:
result = sf.Case.create({
'ContactId': contact_id,
'AccountId': account_id,
'Subject': subject,
'Description': description,
'Priority': priority,
'Status': 'New',
'Origin': 'AI Agent'
})
case_id = result['id']
print(f'Created Case: {case_id}')
return case_id
if __name__ == '__main__':
class FakeCase:
def create(self, data):
return {'id': '500NEW01'}
class FakeSF:
Case = FakeCase()
create_case(FakeSF(), '003ABC', '001XYZ', 'Cannot reset password', 'Customer locked out after 3 attempts')
Verbinden met HubSpot
De bibliotheek hubspot-api-client biedt een omhulsel rond de REST API van HubSpot. Verifieer je met een toegangstoken voor een privé-app (voor server-naar-serverintegraties is geen OAuth nodig).
from hubspot import HubSpot
from hubspot.crm.contacts import SimplePublicObjectInput
client = HubSpot(access_token='YOUR_HUBSPOT_PRIVATE_APP_TOKEN')
print('HubSpot client ready')Een HubSpot-contactpersoon zoeken
Gebruik de zoek-API voor contactpersonen om een klant op e-mailadres te vinden. Het antwoord bevat alle eigenschappen van de contactpersoon, waaronder de levenscyclusfase, dealkoppelingen en aangepaste velden.
from hubspot.crm.contacts import PublicObjectSearchRequest
def get_hubspot_contact(client, email: str) -> dict | None:
search_request = PublicObjectSearchRequest(
filter_groups=[{
'filters': [{
'propertyName': 'email',
'operator': 'EQ',
'value': email
}]
}],
properties=['firstname', 'lastname', 'email',
'lifecyclestage', 'hs_object_id']
)
response = client.crm.contacts.search_api.do_search(
public_object_search_request=search_request
)
if response.total == 0:
return None
contact = response.results[0]
return {'id': contact.id, **contact.properties}HubSpot-ticketgeschiedenis ophalen
HubSpot slaat ondersteuningstickets op in het object tickets. Haal via de associatie-API de gekoppelde tickets van een contactpersoon op.
def get_hubspot_tickets(client, contact_id: str) -> list:
assoc = client.crm.contacts.associations_api.get_all(
contact_id,
to_object_type='tickets'
)
ticket_ids = [r.id for r in assoc.results]
if not ticket_ids:
return []
tickets = []
for tid in ticket_ids[:10]: # limit to 10 most recent
ticket = client.crm.tickets.basic_api.get_by_id(
tid,
properties=['subject', 'hs_ticket_priority',
'hs_pipeline_stage', 'createdate']
)
tickets.append({
'id': tid,
'subject': ticket.properties.get('subject'),
'priority': ticket.properties.get('hs_ticket_priority'),
'stage': ticket.properties.get('hs_pipeline_stage')
})
return tickets
if __name__ == '__main__':
from types import SimpleNamespace
class AssocApi:
def get_all(self, contact_id, to_object_type):
return SimpleNamespace(results=[SimpleNamespace(id='t1'), SimpleNamespace(id='t2')])
class TicketsBasicApi:
_data = {
't1': {'subject': 'Cannot login', 'hs_ticket_priority': 'HIGH', 'hs_pipeline_stage': '1'},
't2': {'subject': 'Refund request', 'hs_ticket_priority': 'MEDIUM', 'hs_pipeline_stage': '2'},
}
def get_by_id(self, tid, properties):
return SimpleNamespace(properties=self._data[tid])
fake_client = SimpleNamespace(crm=SimpleNamespace(
contacts=SimpleNamespace(associations_api=AssocApi()),
tickets=SimpleNamespace(basic_api=TicketsBasicApi()),
))
for t in get_hubspot_tickets(fake_client, 'contact_1'):
print(f"Ticket {t['id']}: {t['subject']} [{t['priority']}]")
Een HubSpot-ticket maken
Voeg één nieuw ticket toe en koppel het in één werkstroom aan de contactpersoon. Zo blijft het CRM-dossier van de klant automatisch bijgewerkt terwijl de medewerker verzoeken afhandelt.
from hubspot.crm.tickets import SimplePublicObjectInputForCreate
from hubspot.crm.associations.v4.models import AssociationSpec
def create_hubspot_ticket(client, contact_id: str,
subject: str, description: str) -> str:
ticket_input = SimplePublicObjectInputForCreate(
properties={
'subject': subject,
'content': description,
'hs_ticket_priority': 'MEDIUM',
'hs_pipeline': 'support_pipeline',
'hs_pipeline_stage': 'new'
},
associations=[{
'types': [AssociationSpec(association_category='HUBSPOT_DEFINED',
association_type_id=16)],
'to': {'id': contact_id}
}]
)
ticket = client.crm.tickets.basic_api.create(
simple_public_object_input_for_create=ticket_input
)
return ticket.idEen contactpersoon bijwerken
Werk na een geslaagde oplossing het dossier van de contactpersoon bij met notities en wijzigingen in de levenscyclusfase. Zo blijft het CRM actueel zonder handmatig werk van de medewerker.
def update_hubspot_contact(client, contact_id: str, updates: dict) -> None:
client.crm.contacts.basic_api.update(
contact_id=contact_id,
simple_public_object_input=SimplePublicObjectInput(
properties=updates
)
)
# After resolving a billing issue:
update_hubspot_contact(client, 'CONTACT_123', {
'hs_lead_status': 'CONNECTED',
'notes_last_contacted': 'Resolved billing duplicate charge issue via AI agent.'
})Geïntegreerde CRM-context voor de agent
Bouw één functie die klantcontext ophaalt uit het geconfigureerde CRM-systeem. De agent roept deze aan het begin van elk gesprek aan om zijn antwoorden te personaliseren.
def get_customer_context(email: str, crm: str = 'salesforce') -> dict:
if crm == 'salesforce':
customer = get_customer_by_email(sf, email)
if not customer:
return {'found': False}
cases = get_case_history(sf, customer['contact_id'])
return {'found': True, 'customer': customer, 'history': cases}
elif crm == 'hubspot':
customer = get_hubspot_contact(client, email)
if not customer:
return {'found': False}
tickets = get_hubspot_tickets(client, customer['id'])
return {'found': True, 'customer': customer, 'history': tickets}
return {'found': False, 'error': 'Unknown CRM'}Welke querytaal wordt gebruikt om via de simple-salesforce-bibliotheek records op te halen?
Salesforce gebruikt een eigen querytaal om records op te halen. Kennis hiervan is essentieel voor het bouwen van agenttools die de klantgeschiedenis opzoeken.
Samenvatting van CRM-integratie
Integratie met Salesforce (simple-salesforce + SOQL) of HubSpot geeft je klantenservice-agent volledige klantcontext: geschiedenis, cases, tickets en accountgegevens.
Bouw altijd één geïntegreerde functie get_customer_context(), zodat de prompt van de agent vóór het genereren van een antwoord wordt verrijkt met relevante geschiedenis.
Leer AI-agenten met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 60
- Lessen
- 239
Veelgestelde vragen
Is de les “CRM-integratie: Salesforce en HubSpot” gratis?
Ja — de volledige tekst van “CRM-integratie: Salesforce en HubSpot” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus AI-agenten wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus AI-agenten bevat in totaal 4 lessen.
Wat leer ik in “CRM-integratie: Salesforce en HubSpot”?
Klantgeschiedenis ophalen, interacties registreren en CRM-records bijwerken. Je oefent met AI-agenten door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met AI-agenten te beginnen?
Ervaring vooraf is niet nodig. AI-agenten op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “CRM-integratie: Salesforce en HubSpot”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over AI-agenten?
Ja. Elke les over AI-agenten bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Ticketroutering en escalatielogica
- CRM-integratie: Salesforce en HubSpot
- Protocollen voor overdracht aan medewerkers
- Klantcontext en -geschiedenis beheren