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

# AND-/OR-Operatoren

> Überschreiben Sie den standardmäßigen AND-/OR-Operator für jeden Mehrwert-Filter — vollständige Referenz mit kopierbaren Beispielen.

`filter_conditions` ist ein einzelnes optionales Array im Anfrage-Body. Jeder Eintrag hebt einen Mehrwert-Filter vom standardmäßigen OR-Verhalten („beliebiger Treffer") auf AND-Verhalten („alle müssen zutreffen") an — oder umgekehrt. Nicht aufgeführte Filter behalten ihre Standardwerte.

## Schema

<CodeGroup>
  ```json JSON theme={null}
  {
    "filter_conditions": [
      { "key": "technologies", "operator": "and" },
      { "key": "verticals",    "operator": "or"  }
    ]
  }
  ```

  ```typescript TypeScript theme={null}
  type FilterCondition = {
    /** Zu überschreibender Filtername. Siehe „Unterstützte Schlüssel" unten. */
    key: string;
    /** Groß-/Kleinschreibung wird ignoriert: "and" | "or". Standard für Arrays ist "or". */
    operator: "and" | "or";
  };

  type SearchRequest = {
    // …all your other filters…
    filter_conditions?: FilterCondition[];
  };
  ```
</CodeGroup>

<Note>
  `key` und `operator` sind bei jedem Eintrag erforderlich. Ein Eintrag mit nur `operator` wird stillschweigend ignoriert — es gibt keine globale Überschreibung.
</Note>

***

## Warum das wichtig ist

Der Standardoperator ist OR, da die meisten Prospecting-Workflows eine breite Reichweite wollen: „Personen in *einem beliebigen* dieser Länder", „Unternehmen mit *einem beliebigen* dieser Vertical-Tags". Für hochpräzises Targeting — „nutzt *alle* von `Salesforce` + `HubSpot` + `Marketo`" — benötigen Sie AND.

Die Kosten eines Fehlers:

* **AND gewollt, OR erhalten:** Die Antwort liefert zu viele Treffer — Sie sehen Unternehmen, die nur ein einziges Tag treffen, nicht den vollständigen Stack. Leicht zu erkennen, kostet Ergebnisqualität.
* **OR gewollt, AND erhalten:** Die Antwort liefert zu wenige Treffer — bei Mehrwert-AND-Filtern kommen üblicherweise fast null Zeilen zurück, da reale Arrays selten jeden angefragten Wert enthalten. Leicht zu erkennen, wirkt wie eine fehlerhafte Abfrage.

Intern kompiliert die Engine Ihre Operatorwahl zu einem nativen Postgres-Array-Operator: `&&` (Überschneidung) für OR, `@>` (enthält) für AND. Beide sind indexfreundlich, sodass sich der Kostenunterschied auf die *Ergebnisgröße* auswirkt, nicht auf die Abfragelatenz.

***

## Unterstützte Schlüssel

Die genaue Schlüsselmenge hängt vom aufgerufenen Endpunkt ab:

| Schlüssel                                | `/companies/search` | `/people/search` | `/companies/advertisements/search` | Standard | Was `and` bedeutet                                         |
| ---------------------------------------- | ------------------- | ---------------- | ---------------------------------- | -------- | ---------------------------------------------------------- |
| `technologies`                           | ja                  | ja               | —                                  | OR       | Hat jede Technologie in der Liste                          |
| `categories`                             | ja                  | ja               | —                                  | OR       | Mit jeder Kategorie getaggt                                |
| `verticals`                              | ja                  | ja               | —                                  | OR       | Gehört zu jedem Vertical                                   |
| `vertical_categories`                    | ja                  | ja               | —                                  | OR       | In jeder Vertical-Kategorie                                |
| `vertical_sub_categories`                | ja                  | ja               | —                                  | OR       | In jeder Vertical-Unterkategorie                           |
| `keywords`                               | ja                  | ja               | —                                  | OR       | Beschreibung enthält jedes Schlüsselwort                   |
| `places`                                 | ja                  | ja               | —                                  | OR       | In jedem Ort gelistet                                      |
| `exclude_places`                         | ja                  | ja               | —                                  | OR       | Aus jedem Ort ausgeschlossen                               |
| `advertisement_target_locations`         | ja                  | —                | —                                  | OR       | Anzeige richtet sich an jedes Land (Unternehmens-Endpunkt) |
| `advertisement_exclude_target_locations` | ja                  | —                | —                                  | OR       | Anzeige schließt jedes Land aus                            |
| `advertisement_search_terms`             | ja                  | —                | —                                  | OR       | Anzeigentext enthält jeden Begriff                         |
| `job_exclude_locations`                  | ja                  | —                | —                                  | OR       | Stellenausschreibung schließt jeden Standort aus           |
| `social_media`                           | —                   | ja               | —                                  | OR       | Person hat alle aufgeführten Social-Media-Konten           |
| `target_locations`                       | —                   | —                | ja                                 | OR       | Anzeige richtet sich an jedes Land (Anzeigen-Endpunkt)     |
| `exclude_target_locations`               | —                   | —                | ja                                 | OR       | Anzeige schließt jedes Land aus                            |

<Tip>
  Die obigen Schlüssel spiegeln die `enum`-Arrays in der OpenAPI-Spezifikation wider (`company_filter_conditions`, `people_filter_conditions`, `ads_filter_conditions`). Das Senden eines nicht unterstützten Schlüssels für einen Endpunkt wird stillschweigend ignoriert.
</Tip>

***

## Rezepte

<Tabs>
  <Tab title="Alle Technologien (Unternehmen)">
    **Ziel:** Unternehmen, die *alle* von Python, PostgreSQL und Kubernetes nutzen — nicht nur eine.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X POST https://api.pubrio.com/companies/search \
        -H "Content-Type: application/json" \
        -H "pubrio-api-key: YOUR_API_KEY" \
        -d '{
          "technologies": [37, 152, 408],
          "filter_conditions": [
            { "key": "technologies", "operator": "and" }
          ],
          "per_page": 25,
          "page": 1
        }'
      ```

      ```python Python theme={null}
      import requests

      response = requests.post(
          "https://api.pubrio.com/companies/search",
          headers={
              "Content-Type": "application/json",
              "pubrio-api-key": "YOUR_API_KEY",
          },
          json={
              "technologies": [37, 152, 408],
              "filter_conditions": [
                  { "key": "technologies", "operator": "and" }
              ],
              "per_page": 25,
              "page": 1,
          },
      )
      print(response.json())
      ```

      ```javascript Node.js theme={null}
      const response = await fetch("https://api.pubrio.com/companies/search", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "pubrio-api-key": "YOUR_API_KEY",
        },
        body: JSON.stringify({
          technologies: [37, 152, 408],
          filter_conditions: [
            { key: "technologies", operator: "and" }
          ],
          per_page: 25,
          page: 1,
        }),
      });
      console.log(await response.json());
      ```
    </CodeGroup>

    Entfernen Sie den `filter_conditions`-Eintrag, um die Suche auf *eine beliebige* der drei Technologien zu erweitern.
  </Tab>

  <Tab title="Beliebige Standorte + Ausschluss">
    **Ziel:** Unternehmen in *einem beliebigen* der USA, Kanadas oder des Vereinigten Königreichs, aber nie in San Francisco.

    OR ist für `locations` bereits der Standard, also lassen wir es implizit. `exclude_places` übernimmt den negativen Filter unabhängig — keine Überschreibung nötig.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X POST https://api.pubrio.com/companies/search \
        -H "Content-Type: application/json" \
        -H "pubrio-api-key: YOUR_API_KEY" \
        -d '{
          "locations": ["US", "CA", "GB"],
          "exclude_places": ["San Francisco"],
          "per_page": 25,
          "page": 1
        }'
      ```

      ```python Python theme={null}
      import requests

      response = requests.post(
          "https://api.pubrio.com/companies/search",
          headers={
              "Content-Type": "application/json",
              "pubrio-api-key": "YOUR_API_KEY",
          },
          json={
              "locations": ["US", "CA", "GB"],
              "exclude_places": ["San Francisco"],
              "per_page": 25,
              "page": 1,
          },
      )
      print(response.json())
      ```

      ```javascript Node.js theme={null}
      const response = await fetch("https://api.pubrio.com/companies/search", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "pubrio-api-key": "YOUR_API_KEY",
        },
        body: JSON.stringify({
          locations: ["US", "CA", "GB"],
          exclude_places: ["San Francisco"],
          per_page: 25,
          page: 1,
        }),
      });
      console.log(await response.json());
      ```
    </CodeGroup>
  </Tab>

  <Tab title="Multi-Region-Werbekampagnen">
    **Ziel:** Anzeigen, die aktiv sowohl die EU *als auch* die USA anvisieren (Multi-Region-Kampagnen) — keine Ein-Markt-Anzeigen. Verwendet das dedizierte `ads_filter_conditions`-Schema mit dem Schlüssel `target_locations`.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X POST https://api.pubrio.com/companies/advertisements/search \
        -H "Content-Type: application/json" \
        -H "pubrio-api-key: YOUR_API_KEY" \
        -d '{
          "target_locations": ["US", "DE", "FR"],
          "filter_conditions": [
            { "key": "target_locations", "operator": "and" }
          ],
          "start_dates": ["2026-01-01"],
          "end_dates":   ["2026-04-22"],
          "per_page": 25,
          "page": 1
        }'
      ```

      ```python Python theme={null}
      import requests

      response = requests.post(
          "https://api.pubrio.com/companies/advertisements/search",
          headers={
              "Content-Type": "application/json",
              "pubrio-api-key": "YOUR_API_KEY",
          },
          json={
              "target_locations": ["US", "DE", "FR"],
              "filter_conditions": [
                  { "key": "target_locations", "operator": "and" }
              ],
              "start_dates": ["2026-01-01"],
              "end_dates":   ["2026-04-22"],
              "per_page": 25,
              "page": 1,
          },
      )
      print(response.json())
      ```

      ```javascript Node.js theme={null}
      const response = await fetch("https://api.pubrio.com/companies/advertisements/search", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "pubrio-api-key": "YOUR_API_KEY",
        },
        body: JSON.stringify({
          target_locations: ["US", "DE", "FR"],
          filter_conditions: [
            { key: "target_locations", operator: "and" }
          ],
          start_dates: ["2026-01-01"],
          end_dates:   ["2026-04-22"],
          per_page: 25,
          page: 1,
        }),
      });
      console.log(await response.json());
      ```
    </CodeGroup>

    <Note>
      Der Anzeigen-Endpunkt verwendet sein eigenes `ads_filter_conditions`-Schema (kleinere Schlüsselmenge: `target_locations`, `exclude_target_locations`). Die auf `/companies/search` und `/people/search` überschreibbaren Schlüssel gelten hier *nicht*.
    </Note>
  </Tab>

  <Tab title="Personen bei Multi-Stack-Unternehmen">
    **Ziel:** Personen, die bei Unternehmen arbeiten, bei denen *sowohl* Salesforce als auch HubSpot installiert sind — ein klassisches CRM-Ablösungssignal. Zeigt die einheitliche Engine: derselbe `technologies`-Schlüssel, derselbe Operator, aber auf `/people/search`.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X POST https://api.pubrio.com/people/search \
        -H "Content-Type: application/json" \
        -H "pubrio-api-key: YOUR_API_KEY" \
        -d '{
          "people_titles": ["RevOps", "Sales Operations"],
          "technologies": [114, 287],
          "filter_conditions": [
            { "key": "technologies", "operator": "and" }
          ],
          "per_page": 25,
          "page": 1
        }'
      ```

      ```python Python theme={null}
      import requests

      response = requests.post(
          "https://api.pubrio.com/people/search",
          headers={
              "Content-Type": "application/json",
              "pubrio-api-key": "YOUR_API_KEY",
          },
          json={
              "people_titles": ["RevOps", "Sales Operations"],
              "technologies": [114, 287],
              "filter_conditions": [
                  { "key": "technologies", "operator": "and" }
              ],
              "per_page": 25,
              "page": 1,
          },
      )
      print(response.json())
      ```

      ```javascript Node.js theme={null}
      const response = await fetch("https://api.pubrio.com/people/search", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "pubrio-api-key": "YOUR_API_KEY",
        },
        body: JSON.stringify({
          people_titles: ["RevOps", "Sales Operations"],
          technologies: [114, 287],
          filter_conditions: [
            { key: "technologies", operator: "and" }
          ],
          per_page: 25,
          page: 1,
        }),
      });
      console.log(await response.json());
      ```
    </CodeGroup>
  </Tab>
</Tabs>

***

## Häufige Fehler

<AccordionGroup>
  <Accordion title="key vergessen, nur operator gesendet" icon="circle-xmark">
    Es gibt keinen globalen „Standardoperator"-Schalter. Jeder Eintrag muss einen konkreten Filter benennen:

    ```json theme={null}
    // Wird ignoriert — kein key
    { "filter_conditions": [{ "operator": "and" }] }

    // Korrekt — überschreibt nur den technologies-Filter
    { "filter_conditions": [{ "key": "technologies", "operator": "and" }] }
    ```
  </Accordion>

  <Accordion title="Erwarten, dass sich Einträge kombinieren" icon="circle-xmark">
    Einträge sind unabhängige Überschreibungen pro Schlüssel — sie verketten sich nicht. Das Auflisten von sowohl `technologies` als auch `verticals` erzeugt keinen booleschen Ausdruck zwischen ihnen; jeder setzt lediglich den Operator seines eigenen Arrays.

    Die Kombination *zwischen* Filterschlüsseln ist immer AND (jeder Filter muss zutreffen). Sie können zwei unterschiedliche Filterdimensionen nicht über `filter_conditions` mit OR verknüpfen. Wenn Sie eine echte OR-Verknüpfung unterschiedlicher Filter benötigen, führen Sie zwei Anfragen aus und führen Sie die Ergebnisse clientseitig zusammen.
  </Accordion>

  <Accordion title="AND bei einem langen Array verwenden" icon="triangle-exclamation">
    AND ist `column @> ARRAY[…]` — jeder Wert muss vorhanden sein. Bei 8+ Werten erhalten Sie fast immer null Zeilen, da reale Tagging-Daten spärlich sind. Halten Sie AND-überschriebene Arrays bei 2–4 Werten; verwenden Sie OR für explorative oder kategorienbasierte Filterung.
  </Accordion>

  <Accordion title="Falscher Schlüssel bei /people/search-Unternehmensfiltern" icon="circle-xmark">
    Bei `/people/search` lautet der People-API-Name `company_places` / `company_locations`. Aber innerhalb von `filter_conditions[].key` müssen Sie den **Engine-Namen** verwenden — `places`, `locations`. Die Umbenennung erfolgt intern, bevor `filter_conditions` berücksichtigt wird.

    ```json theme={null}
    // Überschreibt nicht — die Engine erkennt "company_places" nicht als Filterschlüssel
    { "filter_conditions": [{ "key": "company_places", "operator": "and" }] }

    // Korrekt
    { "filter_conditions": [{ "key": "places", "operator": "and" }] }
    ```

    Die vollständige Umbenennungstabelle finden Sie auf der Seite [People + Company Filters](/de/developer-guides/filters/people-with-company-filters#key-remap-reference).
  </Accordion>
</AccordionGroup>

<Tip>
  Im Zweifelsfall lassen Sie `filter_conditions` zunächst weg und prüfen Sie Ihre Ergebnisanzahl gegen die Erwartung. Fügen Sie Überschreibungen nur für Filter hinzu, bei denen der Standard nicht Ihrer Absicht entspricht — das hält den Anfrage-Payload kleiner und leichter zu debuggen.
</Tip>

***

## Siehe auch

<CardGroup cols={2}>
  <Card title="Filters Overview" icon="filter" href="/de/developer-guides/filters/overview">
    Das mentale Modell — beginnen Sie hier, wenn `filter_conditions` Ihre erste Anlaufstelle ist.
  </Card>

  <Card title="People + Company Filters" icon="users-rectangle" href="/de/developer-guides/filters/people-with-company-filters">
    Wie Sie Unternehmensfilter in `/people/search` einbinden, einschließlich der Schlüssel-Umbenennung.
  </Card>

  <Card title="Company Search reference" icon="building" href="/de/api-reference/endpoint/companies/search">
    Vollständiges Anfrageschema für `/companies/search` (enthält `company_filter_conditions`).
  </Card>

  <Card title="People Search reference" icon="user" href="/de/api-reference/endpoint/people/search">
    Vollständiges Anfrageschema für `/people/search` (enthält `people_filter_conditions`).
  </Card>
</CardGroup>
