# KI-Agent an Salesforce anbinden: APIs, MCP und Agentforce-Abgrenzung

> Ein eigener KI-Agent greift über eine External Client App und OAuth auf die Salesforce-REST-API und SOQL zu oder als MCP-Client auf die Hosted MCP Servers. MCP läuft nur im Namen angemeldeter Nutzer; Hintergrund-Agenten brauchen die REST-API mit Integrationsnutzer.

Kanonische URL: https://www.ruebstudio.de/de/wissen/ki-agenten-anbinden/ki-agent-salesforce-anbinden  
Autor: Dr.-Ing. Marcus Rüb, CEO  
Veröffentlicht: 2026-11-08

Wer einen eigenen KI-Agenten mit Salesforce verbinden will, hat drei Wege: die REST-API mit SOQL, die von Salesforce betriebenen MCP-Server oder Agentforce, die Agentenschicht von Salesforce selbst. Die Wahl hängt weniger vom Modell ab als von einer schlichten Frage: Arbeitet der Agent im Auftrag eines angemeldeten Menschen oder unbeaufsichtigt im Hintergrund? Dieser Überblick ordnet die Wege ein, Stand November 2026.

## Was bedeutet es, einen KI-Agenten an Salesforce anzubinden?

Anbinden heißt: Ein Agent außerhalb von Salesforce darf Datensätze lesen, suchen und gezielt ändern, mit klar begrenzten Rechten. Typisch sind Opportunities zusammenfassen, Kontakte vor einem Termin aufbereiten, Aktivitäten nachtragen oder Fälle aus dem Service vorsortieren. Salesforce bleibt dabei das maßgebliche System für Kundendaten.

Der Agent selbst läuft in Ihrer Umgebung, nutzt ein Sprachmodell Ihrer Wahl und kombiniert Salesforce mit anderen Quellen: ERP, Ticketsystem, Dokumentenablage, E-Mail. Genau das unterscheidet ihn von Agentforce, das innerhalb der Salesforce-Plattform läuft. Für Vertriebsaufgaben beschreibt der Artikel zum [Sales-Agent](https://www.ruebstudio.de/de/wissen/ki-agenten-nach-fachbereich/sales-agent-ki-vertrieb), was ein solcher Agent fachlich leisten kann; hier geht es um die technische Anbindung an Salesforce.

Wenn Ihr CRM HubSpot ist, gilt dieselbe Grundfrage, aber mit anderen Bausteinen: Der Artikel [KI-Agent an HubSpot anbinden](https://www.ruebstudio.de/de/wissen/ki-agenten-anbinden/ki-agent-hubspot-anbinden) behandelt dort Service Keys und den HubSpot-MCP-Server. Bei Salesforce kommen zwei Besonderheiten hinzu, die es bei HubSpot so nicht gibt: die Umstellung von Connected Apps auf External Client Apps und die harte Trennung zwischen nutzerbezogenem MCP-Zugriff und Server-zu-Server-Zugriff.

## Wie funktioniert die Anbindung? Die Bausteine

Jede Anbindung besteht aus vier Teilen: einer registrierten App in Salesforce, einem OAuth-Flow für das Zugriffstoken, einer Schnittstelle (REST-API oder MCP-Server) und einem Benutzerkontext, dessen Rechte der Agent erbt. Wer diese vier Teile bewusst wählt, hat die Architektur im Wesentlichen festgelegt.

### External Client App statt Connected App

Damit ein externes Programm auf die REST-API zugreifen darf, braucht es eine registrierte App mit OAuth-Einstellungen. Lange war das die Connected App. Laut [REST API Developer Guide](https://developer.salesforce.com/docs/platform/api-rest/guide/intro-oauth-and-connected-apps.html) ist das Anlegen neuer Connected Apps seit Spring ’26 eingeschränkt; bestehende Apps laufen weiter, für Ausnahmen müssen Sie den Support kontaktieren, empfohlen werden External Client Apps. Salesforce beschreibt External Client Apps als [neue Generation](https://developer.salesforce.com/docs/platform/mobile-sdk/guide/connected-apps.html), die Sicherheit verbessern und Probleme bei Paketierung und Verteilung lösen soll.

Für ein neues Agentenprojekt heißt das praktisch: Planen Sie von Anfang an mit einer External Client App. Für die Hosted MCP Servers ist das ohnehin Pflicht, Connected Apps werden dort laut [Salesforce-Anleitung](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/create-external-client-app.html) nicht unterstützt.

### OAuth-Flows: Mensch oder Integrationsnutzer

Der OAuth-Flow entscheidet, in wessen Namen der Agent handelt. Beim Authorization-Code-Flow meldet sich ein Mensch im Browser an, der Agent erhält dessen Rechte. Beim [Client-Credentials-Flow](https://help.salesforce.com/s/articleView?id=xcloud.remoteaccess_oauth_client_credentials_flow.htm&type=5) tauscht die App Consumer Key und Consumer Secret gegen ein Token, das im Namen eines festgelegten Integrationsnutzers gilt.

Salesforce nennt den Client-Credentials-Flow ausdrücklich als sicherere Alternative zum Username-Password-Flow. Drei Details aus der Dokumentation sind für Agenten wichtig:

- Der Flow liefert keine Refresh Tokens. Läuft das Token ab, holt der Agent ein neues.
- Anfragen an `login.salesforce.com` und `test.salesforce.com` werden nicht unterstützt; Sie verwenden die My-Domain-URL Ihrer Org.
- Wer Consumer Key und Secret kennt, bekommt ein Token. Salesforce empfiehlt, das Secret regelmäßig zu wechseln und bei Verdacht sofort.

### REST-API und SOQL

Die REST-API ist der allgemeine Zugang zu Datensätzen. Lesen läuft meist über die [Query-Ressource](https://developer.salesforce.com/docs/platform/api-rest/guide/resources-query.html) unter `/services/data/vXX.X/query?q=…` mit einer SOQL-Abfrage. Eine synchrone Antwort enthält laut Dokumentation bis zu 2.000 Datensätze, bei komplexen Datensätzen auch weniger; ist `done` false, holt der Agent den Rest über `nextRecordsUrl`.

Die Beispiele in der Salesforce-Dokumentation verwenden derzeit die API-Version v68.0 (Stand November 2026). Legen Sie die Version in Ihrer Anbindung fest, statt sie dynamisch zu ermitteln, damit sich das Verhalten nicht mit einem Release unbemerkt ändert.

```python
# Minimalskizze: Token per Client-Credentials-Flow, dann SOQL-Abfrage
import os
import requests

base = os.environ["SF_MY_DOMAIN_URL"]  # z. B. https://ihrefirma.my.salesforce.com
token = requests.post(
    f"{base}/services/oauth2/token",
    data={
        "grant_type": "client_credentials",
        "client_id": os.environ["SF_CONSUMER_KEY"],
        "client_secret": os.environ["SF_CONSUMER_SECRET"],
    },
    timeout=30,
).json()["access_token"]

soql = "SELECT Id, Name, StageName, CloseDate FROM Opportunity WHERE IsClosed = false"
url = f"{base}/services/data/v68.0/query"
params = {"q": soql}
records = []
while url:
    r = requests.get(url, params=params,
                     headers={"Authorization": f"Bearer {token}"}, timeout=30)
    r.raise_for_status()
    body = r.json()
    records += body["records"]
    # Folgeseiten über nextRecordsUrl, ohne Parameter
    url = base + body["nextRecordsUrl"] if not body["done"] else None
    params = None
print(len(records), "offene Opportunities")
```

Die Skizze folgt den Endpunkten aus der Salesforce-Dokumentation (Token-Endpunkt laut Hilfeartikel zum Client-Credentials-Flow, Paging laut [Execute a SOQL Query](https://developer.salesforce.com/docs/platform/api-rest/guide/dome-query.html)). Für den Agenten wird daraus ein Werkzeug („offene Opportunities lesen“), das das Modell aufruft, statt frei SOQL zu formulieren.

### Hosted MCP Servers

Salesforce betreibt eigene MCP-Server. Jeder MCP-fähige Client, laut [Salesforce](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide) etwa Claude, ChatGPT, Cursor oder ein eigener Agent, kann sich verbinden und im Namen berechtigter Nutzer handeln. Die Server-URL hat die Form `https://api.salesforce.com/platform/mcp/v1/platform/sobject-all`, mit Varianten für My Domain und Sandboxes.

Die [Standardserver](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/references/reference/servers-reference.html) sind nach Rechten geschnitten: `sobject-all` (lesen, anlegen, ändern, löschen), `sobject-reads` (nur lesen), `sobject-mutations` (anlegen und ändern, kein Löschen) und `sobject-deletes`. Dazu kommen produktbezogene Server, etwa für Data 360 und Tableau Next. Alle Standardserver sind ab Werk ausgeschaltet und müssen von einem Admin aktiviert werden.

Für die External Client App verlangt Salesforce die Scopes `mcp_api` und `refresh_token` sowie JWT-basierte Access Tokens; bis die App nutzbar ist, kann es [bis zu 30 Minuten](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/create-external-client-app.html) dauern. Planen Sie das im ersten Test ein, bevor Sie eine Fehlkonfiguration vermuten.

## Welche Varianten gibt es, und wann passt welche?

Es gibt drei Varianten: eigener Agent über REST-API, eigener Agent oder KI-Client über Hosted MCP, und Agentforce. Sie schließen sich nicht aus. Entscheidend sind Benutzerkontext, Datenquellen außerhalb von Salesforce und der Ort, an dem Modell und Logik laufen sollen.

| Kriterium | REST-API + SOQL | Hosted MCP Servers | Agentforce |
|---|---|---|---|
| Läuft im Namen von | Integrationsnutzer oder angemeldetem Nutzer | nur angemeldetem Nutzer | Salesforce-Nutzer bzw. Kanal |
| Unbeaufsichtigte Läufe | ja (Client Credentials) | nein | innerhalb der Plattform |
| Eigener Code nötig | ja | wenig, Konfiguration im Setup | Konfiguration und Agent Script |
| Daten außerhalb von Salesforce | frei kombinierbar | über den Client | über Salesforce-Integrationen |
| Abrechnung | API-Kontingent der Org | Flex Credits laut Salesforce | nach Salesforce-Vertrag |

### Eigener Agent über die REST-API

Dieser Weg passt, wenn der Agent ohne anwesenden Menschen arbeitet: nächtliche Pipeline-Prüfung, automatische Anreicherung neuer Leads, Abgleich mit dem ERP. Sie bauen die Werkzeuge selbst, bestimmen genau, welche Felder der Agent sieht, und können Salesforce mit beliebigen anderen Systemen verbinden. Der Preis ist eigener Code, eigenes Monitoring und ein sorgfältig berechtigter Integrationsnutzer.

### KI-Client oder Agent über Hosted MCP

Dieser Weg passt, wenn Mitarbeitende in einem KI-Client arbeiten und dort Salesforce-Daten brauchen, etwa „Fasse mir die offenen Opportunities dieses Accounts zusammen“. Laut [Sicherheitsleitfaden](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/security-best-practices.html) gilt ausschließlich der Authorization-Code-Flow mit PKCE: keine Servicekonten, keine Maschine-zu-Maschine-Flows, kein autonomer Betrieb außerhalb eines Nutzerkontexts. Jeder Aufruf hat genau die Rechte des angemeldeten Nutzers, inklusive Feldsicherheit und Freigaberegeln.

Das ist für Governance angenehm und für Hintergrundagenten ein klares Ausschlusskriterium. Ein Agent, der um drei Uhr nachts Daten aufbereiten soll, gehört auf die REST-API.

### Agentforce

[Agentforce](https://developer.salesforce.com/docs/ai/agentforce/guide/get-started.html) ist laut Salesforce die agentengetriebene Schicht der Salesforce-Plattform, mit einem Trust Layer zwischen Daten und Sprachmodell. Agenten entstehen im Agentforce Builder oder mit Agent Script, und über die [Agent API](https://developer.salesforce.com/docs/ai/agentforce/guide/get-started-agents.html) lassen sie sich per REST von außen ansprechen. Seit April 2026 heißen die früheren Topics dort Subagents.

Agentforce ist sinnvoll, wenn Daten und Prozess überwiegend in Salesforce liegen, der Agent innerhalb der Salesforce-Oberflächen arbeiten soll und Sie auf ein eigenes Modell und eigene Infrastruktur verzichten können. Ein eigener Agent ist die bessere Wahl, wenn Salesforce nur eine von mehreren Quellen ist, wenn Sie das Modell oder den Betriebsort selbst bestimmen wollen oder wenn dieselbe Logik auch an anderen Systemen arbeiten soll.

## Welche Voraussetzungen braucht die Anbindung?

Sie brauchen Admin-Zugang zum Setup, eine Sandbox zum Testen, einen klaren Zuschnitt der Rechte und Wissen über Ihr Datenmodell. Der Aufwand liegt meist weniger in der Technik als in Rechten, Feldauswahl und sauberen Testdaten.

- **Edition und Kontingent:** Die REST-API zählt gegen das tägliche API-Kontingent der Org. Den aktuellen Stand liefert die [Limits-Ressource](https://developer.salesforce.com/docs/platform/api-rest/guide/resources-limits.html) unter `/services/data/vXX.X/limits/` (Eintrag `DailyApiRequests`); sie ist laut Salesforce auf etwa fünf Minuten genau und setzt die Berechtigung „View Setup and Configuration“ voraus.
- **Integrationsnutzer:** Für den Client-Credentials-Flow ein eigener Nutzer mit Permission Set, das nur die nötigen Objekte und Felder freigibt. Nie ein Admin-Konto.
- **Datenmodell:** Welche Objekte und Felder braucht der Agent wirklich? Eigene Felder und Objekte (`__c`) sind in jeder Org anders; der Agent braucht eine Beschreibung, was sie bedeuten.
- **Flex Credits für MCP:** Die Hosted MCP Servers sind laut Salesforce nur für Kunden mit Flex Credits gedacht, die Nutzung kann abgerechnet werden.
- **Datenschutz:** Kundendaten fließen an ein Sprachmodell. Klären Sie Auftragsverarbeitung, Speicherort und welche Felder (Notizen, E-Mail-Inhalte) gar nicht erst übertragen werden. Eine solche Anbindung ist datenschutzkonform betreibbar, das ist aber eine Frage der Konfiguration und Verträge, keine Eigenschaft der Technik; im Zweifel ziehen Sie Ihre Datenschutzberatung hinzu.

## Wie gehen Sie in Schritten vor?

Beginnen Sie mit einem lesenden Anwendungsfall in einer Sandbox, messen Sie die Qualität an echten Fragen und erweitern Sie Rechte erst danach. Schreibende Werkzeuge kommen zuletzt und zunächst mit Freigabe durch einen Menschen.

1. **Anwendungsfall festlegen:** Eine konkrete Aufgabe, etwa „Vorbereitung auf Kundentermine aus Account, offenen Opportunities und letzten Aktivitäten“.
2. **Weg wählen:** Nutzerbezogen im KI-Client → Hosted MCP. Unbeaufsichtigt oder mit vielen Fremdsystemen → REST-API. Überwiegend in Salesforce, ohne eigenes Modell → Agentforce prüfen.
3. **External Client App anlegen:** In der Sandbox, mit minimalen Scopes. Bei MCP Callback-URL des Clients eintragen, bei REST den Client-Credentials-Flow aktivieren und den Integrationsnutzer festlegen.
4. **Werkzeuge schneiden:** Statt freier SOQL-Abfragen feste Werkzeuge mit Parametern. Bei MCP bietet Salesforce dafür [eigene Server](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/custom-servers.html), die Apex Invocable Actions, Flows und Named Queries als Werkzeuge bündeln.
5. **Mit echten Fragen testen:** Zwanzig bis dreißig typische Fragen aus dem Vertrieb sammeln und die Antworten fachlich prüfen lassen.
6. **Schreibrechte schrittweise:** Zuerst Entwürfe (Aufgabe, Notiz), die ein Mensch bestätigt. Löschrechte praktisch nie.
7. **Produktion und Überwachung:** Kontingent, Fehlerraten und Kosten beobachten. MCP-Zugriffe lassen sich laut Salesforce in den API-Logs über `API_CLIENT_CATEGORY = SALESFORCE_HOSTED_MCP` filtern.

## Welche Grenzen und Risiken gibt es?

Die größten Risiken sind zu weite Rechte, zu viele Werkzeuge und falsch verstandene Daten. Dazu kommen Abhängigkeiten von Salesforce-Releases und Kosten, die bei MCP nach Verbrauch anfallen können.

- **Zu weite Rechte:** Ein Integrationsnutzer mit „View All Data“ macht jeden Prompt-Injection-Versuch gefährlich. Rechte so eng wie möglich, schreibende Aktionen einzeln freigeben.
- **Zu viele Werkzeuge:** Salesforce schreibt selbst, dass KI-Clients ab einigen Dutzend Werkzeugen Schwierigkeiten haben, das richtige auszuwählen. Kleine, aufgabenbezogene Server oder Werkzeugsätze funktionieren besser als `sobject-all` für alle.
- **Datenqualität:** Ein Agent fasst zusammen, was im CRM steht. Veraltete Phasen, leere Pflichtfelder oder doppelte Accounts führen zu überzeugend formulierten, aber falschen Antworten.
- **Release-Wechsel:** Server, Werkzeuge und Prompts der Hosted MCP Servers können sich laut [Salesforce](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/end-of-life.html) von Release zu Release ändern oder eingestellt werden. Testen Sie nach jedem Release.
- **Geheimnisse:** Consumer Secret und Tokens gehören in einen Secret-Speicher, nie in Code, Prompts oder Logs.
- **Kosten:** API-Kontingent bei REST, Flex Credits bei MCP, dazu die Kosten des Sprachmodells. Ohne Monitoring fallen Ausreißer erst auf der Rechnung auf.

In unserem eigenen Betrieb hat sich bewährt, jeden Agenten zuerst nur lesend und mit einer kleinen Liste benannter Werkzeuge zu starten; die Fehler, die dabei sichtbar werden, liegen meist im Datenmodell, nicht im Modell.

## Wie fangen Sie an?

Starten Sie mit einer Sandbox, einer External Client App und einem lesenden Anwendungsfall. Wenn Ihre Mitarbeitenden bereits einen MCP-fähigen KI-Client nutzen, ist `sobject-reads` der schnellste Test; für Hintergrundaufgaben beginnen Sie mit einer festen SOQL-Abfrage über die REST-API.

Halten Sie nach zwei bis drei Wochen Test fest, welche Fragen der Agent gut beantwortet, wo Daten fehlten und welche Werkzeuge nie benutzt wurden. Daraus ergibt sich, ob Sie bei MCP bleiben, auf einen eigenen Agenten mit REST-Zugriff wechseln oder Agentforce genauer prüfen. Wie ein fertiger Agent für Vertrieb, Angebote oder Service aussehen kann, zeigen die Seiten zu [KI-Agenten](https://www.ruebstudio.de/de/ki-agenten) und zum [Vertriebsagenten](https://www.ruebstudio.de/de/ki-agenten/vertrieb).

## Häufige Fragen

### Kann ich für einen neuen Agenten noch eine Connected App anlegen?

Nur noch über den Salesforce-Support. Laut Salesforce ist das Anlegen von Connected Apps seit Spring ’26 eingeschränkt; bestehende laufen weiter, für neue Anbindungen empfiehlt Salesforce External Client Apps.

### Kann ein nächtlicher Agent ohne Benutzeranmeldung die Hosted MCP Servers nutzen?

Nein. Die Hosted MCP Servers akzeptieren laut Salesforce ausschließlich den Authorization-Code-Flow mit PKCE, also einen angemeldeten Nutzer. Für unbeaufsichtigte Läufe nutzen Sie die REST-API mit dem Client-Credentials-Flow und einem Integrationsnutzer.

### Kostet der Zugriff über MCP extra?

Salesforce schreibt, dass die Hosted MCP Servers nur für Kunden mit Flex Credits gedacht sind und die Nutzung abgerechnet werden kann. Klären Sie das vor dem Pilotbetrieb mit Ihrem Salesforce-Ansprechpartner.

### Wie viele Datensätze liefert eine SOQL-Abfrage über die REST-API auf einmal?

Bis zu 2.000 Datensätze pro synchroner Antwort, bei großen Datensätzen auch weniger. Den Rest holen Sie über die nextRecordsUrl aus der Antwort.

## Quellen

- [Salesforce REST API Developer Guide: Authorization Through External Client Apps or Connected Apps and OAuth 2.0](https://developer.salesforce.com/docs/platform/api-rest/guide/intro-oauth-and-connected-apps.html)
- [Salesforce Developers: External Client Apps and Connected Apps](https://developer.salesforce.com/docs/platform/mobile-sdk/guide/connected-apps.html)
- [Salesforce Help: OAuth 2.0 Client Credentials Flow for Server-to-Server Integration](https://help.salesforce.com/s/articleView?id=xcloud.remoteaccess_oauth_client_credentials_flow.htm&type=5)
- [Salesforce REST API Developer Guide: Query](https://developer.salesforce.com/docs/platform/api-rest/guide/resources-query.html)
- [Salesforce REST API Developer Guide: Execute a SOQL Query](https://developer.salesforce.com/docs/platform/api-rest/guide/dome-query.html)
- [Salesforce REST API Developer Guide: Limits](https://developer.salesforce.com/docs/platform/api-rest/guide/resources-limits.html)
- [Salesforce Developers: Salesforce Hosted MCP Servers](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide)
- [Salesforce Hosted MCP Servers: Create an External Client App](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/create-external-client-app.html)
- [Salesforce Hosted MCP Servers: Find Your Server URL](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/server-urls.html)
- [Salesforce Hosted MCP Servers: Security Best Practices](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/security-best-practices.html)
- [Salesforce Hosted MCP Servers: Standard MCP Servers Reference](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/references/reference/servers-reference.html)
- [Salesforce Hosted MCP Servers: Custom MCP Servers](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/custom-servers.html)
- [Salesforce Hosted MCP Servers: End-of-Life](https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/end-of-life.html)
- [Salesforce Developers: Get Started with Agentforce and AI Agents](https://developer.salesforce.com/docs/ai/agentforce/guide/get-started.html)
- [Salesforce Developers: Get Started with Agentforce APIs and SDKs](https://developer.salesforce.com/docs/ai/agentforce/guide/get-started-agents.html)
