> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Shared Connectors

> Verbinde ein einzelnes Servicekonto, das alle App-Benutzer teilen

<div className="dev-docs-banner">
  <div className="dev-docs-banner-content">
    <div className="dev-docs-banner-title">
      Du siehst gerade die Entwicklerdokumentation
    </div>

    <div className="dev-docs-banner-text">
      Diese Dokumentation richtet sich an Entwickler, die mit der Base44-Entwicklerplattform arbeiten. Informationen zu Connectors im App-Editor findest du unter{" "}
      <a href="/Integrations/Connectors">Connectors verwenden</a>.
    </div>
  </div>
</div>

Ein Shared Connector verbindet ein Konto für die gesamte App. Alle App-Benutzer teilen sich denselben OAuth-Token. Verwende dies für Servicekonten, etwa zum Posten in einen Firmen-Slack-Kanal, Lesen aus einem geteilten Google Calendar oder Abfragen eines geteilten Notion-Workspaces.

**So richtest du einen Shared Connector ein:**

1. [**Konfiguriere**](#configure) eine JSONC-Datei für jeden benötigten Dienst
2. [**Deploye und autorisiere**](#deploy-and-authorize) über die CLI
3. [**Verwende in Backend-Funktionen**](#use-in-backend-functions), indem du [`getConnection()`](/developers/references/sdk/docs/interfaces/connectors#getconnection) für OAuth-Connectors aufrufst oder die [Stripe-REST-API](#stripe) direkt für Zahlungen verwendest

## Konfigurieren

Jeder Connector ist eine JSONC-Datei im Connectors-Verzeichnis deines Projekts. Die Datei definiert den Integrationstyp und die Scopes, die deine App benötigt. Standardmäßig ist das Verzeichnis `base44/connectors/`, aber du kannst den Pfad in deiner [Projektkonfiguration](/developers/backend/overview/project-structure#config-jsonc) anpassen.

<Tree>
  <Tree.Folder name="connectors" defaultOpen>
    <Tree.File name="googlecalendar.jsonc" />

    <Tree.File name="slack.jsonc" />

    <Tree.File name="slackbot.jsonc" />

    <Tree.File name="notion.jsonc" />
  </Tree.Folder>
</Tree>

### Beispiel

Dieses Beispiel konfiguriert einen Google-Calendar-Connector mit Lese- und Ereignisverwaltungs-Scopes:

```jsonc theme={null}
{
  "type": "googlecalendar",
  "scopes": [
    "https://www.googleapis.com/auth/calendar.readonly",
    "https://www.googleapis.com/auth/calendar.events",
  ],
}
```

### Feldreferenz

<ResponseField name="type" type="string" required>
  Der Integrationstyp-Identifier. Siehe die Tabelle [unterstützte Dienste](/developers/backend/resources/connectors#supported-services) für die vollständige Liste akzeptierter Werte.

  Jeder Connector-Typ kann in deinem Projekt nur einmal definiert werden.
</ResponseField>

<ResponseField name="scopes" type="array" required>
  Array von OAuth-Scopes, die für deine Integration erforderlich sind. Die konkreten
  Scopes hängen vom externen Dienst und davon ab, welche Operationen deine App durchführen muss.
  Siehe die Dokumentation zu [Connector-Berechtigungen und
  -Scopes](/Integrations/Connectors#connector-permissions) für die verfügbaren Scopes pro Dienst.
</ResponseField>

## Deployen und autorisieren

Deploye Connectors mit [`connectors push`](/developers/references/cli/commands/connectors-push) oder [`deploy`](/developers/references/cli/commands/deploy). Um bestehende Connectors von Base44 herunterzuladen, verwende [`connectors pull`](/developers/references/cli/commands/connectors-pull).

Beim Push behandelt die CLI jeden Connector je nach Typ:

* **OAuth-Connectors:** Die CLI fordert dich auf, jeden Connector einzeln zu autorisieren. Sie schlägt vor, deinen Browser automatisch zu öffnen, und wenn du zustimmst, iteriert sie nacheinander durch die Autorisierungsseite jeder Integration. Nach Abschluss der Autorisierung werden deine OAuth-Tokens sicher gespeichert und du kannst sie über das SDK abrufen.
* **Stripe:** Die CLI stellt eine Stripe-Sandbox für deine App bereit und gibt eine Claim-URL zurück, um das Onboarding abzuschließen. Es ist kein OAuth-Flow erforderlich.

## In Backend-Funktionen verwenden

Sobald deployed und autorisiert, verwende den Connector in deinen [Backend-Funktionen](/developers/backend/resources/backend-functions/overview). Der Ansatz hängt vom Auth-Modell des Connectors ab:

<Tabs>
  <Tab title="OAuth-Connectors">
    Rufe [`connectors.getConnection()`](/developers/references/sdk/docs/interfaces/connectors#getconnection) mit dem Connector-Typ auf, um ein `accessToken` für authentifizierte API-Aufrufe abzurufen. Einige Connectors geben außerdem eine `connectionConfig` mit zusätzlichen Parametern zurück (z. B. eine Subdomain oder Konto-ID).

    Dieses Beispiel ruft eine Google-Calendar-Verbindung ab und holt anstehende Ereignisse:

    ```typescript theme={null}
    const { accessToken } =
      await base44.asServiceRole.connectors.getConnection("googlecalendar");

    const timeMin = new Date().toISOString();
    const url = `https://www.googleapis.com/calendar/v3/calendars/primary/events?maxResults=10&orderBy=startTime&singleEvents=true&timeMin=${timeMin}`;

    const response = await fetch(url, {
      headers: { Authorization: `Bearer ${accessToken}` },
    });

    const events = await response.json();
    ```
  </Tab>

  <Tab title="Stripe">
    Stripe verwendet `getConnection()` nicht. Stattdessen speichert die Plattform deine Stripe-API-Schlüssel als App-Secrets, wenn du den Connector bereitstellst. Lies in deinen Backend-Funktionen `STRIPE_SECRET_KEY` aus der Umgebung und rufe die [Stripe-REST-API](https://docs.stripe.com/api) direkt auf.

    Dieses Beispiel erstellt eine Stripe-Checkout-Sitzung und gibt die Zahlungs-URL zurück:

    ```typescript theme={null}
    const STRIPE_SECRET_KEY = Deno.env.get("STRIPE_SECRET_KEY");

    Deno.serve(async (req) => {
      const { priceId, successUrl, cancelUrl } = await req.json();

      const response = await fetch("https://api.stripe.com/v1/checkout/sessions", {
        method: "POST",
        headers: {
          Authorization: `Bearer ${STRIPE_SECRET_KEY}`,
          "Content-Type": "application/x-www-form-urlencoded",
        },
        body: new URLSearchParams({
          "payment_method_types[]": "card",
          "line_items[0][price]": priceId,
          "line_items[0][quantity]": "1",
          mode: "payment",
          success_url: successUrl || `${req.headers.get("origin")}?success=true`,
          cancel_url: cancelUrl || `${req.headers.get("origin")}?canceled=true`,
        }),
      });

      const session = await response.json();
      return Response.json({ url: session.url });
    });
    ```
  </Tab>
</Tabs>

## Connector-Automationen

Connector-Automationen ermöglichen es deinen Backend-Funktionen, in Echtzeit auf Ereignisse verbundener Dienste zu reagieren. Zum Beispiel kannst du eine Funktion ausführen, wenn eine neue E-Mail in Gmail eintrifft oder eine Datei in Google Drive geändert wird.

Konfiguriere Connector-Automationen in deiner `function.jsonc`-Datei neben deinen anderen Automationen. Siehe [Connector-Automationen](/developers/backend/resources/backend-functions/automations#connector-automations) für die vollständige Feldreferenz, unterstützte Ereignisse und Payload-Dokumentation.

## Siehe auch

* [Connectors-Übersicht](/developers/backend/resources/connectors)
* [App-User-Connectors](/developers/backend/resources/connectors/app-user-connectors)
* [SDK-Connectors-Referenz](/developers/references/sdk/docs/interfaces/connectors#getconnection)
* [connectors push](/developers/references/cli/commands/connectors-push)
* [connectors pull](/developers/references/cli/commands/connectors-pull)
* [deploy](/developers/references/cli/commands/deploy)
* [Backend-Funktionen](/developers/backend/resources/backend-functions/overview)
* [Automationen](/developers/backend/resources/backend-functions/automations)

<Note>Diese Seite wurde mit KI übersetzt. Für die genauesten und aktuellsten Informationen siehe die [englische Version](/). </Note>