---
title: "Listenabfragen (List Inquire)"
url: "https://help.internetx.com/de/api/core-listenabfragen-list-inquire/"
lang: "de"
section: "API-Referenz — API-Referenz (XML/JSON)"
breadcrumb: "Allgemeine API-Grundlagen"
updated: "2023-09-06"
---

# Listenabfragen (List Inquire)

## Beschreibung

Mit Listenabfragen werden die Daten mehrerer oder aller Objekte eines Objekttyps ermittelt. Die zurückgegebenen Listen enthalten für die einzelnen Objekte weniger Details als die Ergebnisse von Einzelabfragen. 

Eine Listenabfrage besteht aus 3 Objekten:

-   Das Objekt _Where (XML) bzw. Filters (JSON)_  legt Suchkriterien fest. Details zum Objekt [_Where_](/de/api/core-objekt-where/) für XML und [_Filters_](/de/api/core-objekt-queryfilter/) für JSON.
    
-   Das Objekt _View_  legt den Umfang des Ergebnisses fest. Details zum Objekt [_View_](/de/api/core-objekt-view/) für XML und JSON.
    
-   Das Objekt _Order_  legt die Sortierung des Ergebnisses fest. Details zum Objekt [_Order_](/de/api/core-objekt-order/) für XML und JSON.
    

Für eine Listenabfrage von sld, subtld, tld müssen die Keywords in einen "Where" bzw. "Filters"-Block eingefügt werden. Es werden immer nur die vollständigen Domain-Namen (z. B. example.com) zurückgegeben, nicht aber die Daten der einzelnen Keys (z.B. .com).

## Auftragstypen und Routen für Listenabfragen

Die  Listenabfragen werden in XML mit den objekt-spezifischen ListInquire-Aufträgen ausgeführt und in JSON über die entsprechenden Routen.

Dies sind: (Liste noch nicht vollständig)

| XML-Auftragstyp | XML-Code | JSON-Route | Beschreibung |
| --- | --- | --- | --- |
| [BackupMX List](/de/api/core-backupmx-list/) | 524 | POST /backupMX/\_search | Ermittelt Daten von  BackupMX-Einträgen. |
| [Certificate Job List](/de/api/core-certificate-job-list/) | 400115 | JobLIst | Ermittelt die Daten von Zonen-Aufträgen. |
| [Certificate List](/de/api/core-certificate-list/) | 400105 | POST /certificate/\_search | Ermittelt die Daten von Zertifikaten. |
| [Contact List](/de/api/core-domain-list/) | 304 | POST /contact​/\_search | Ermittelt Daten von Domain-Kontakten. |
| [Domain List](/de/api/core-domain-list/) | 105 | POST ​/domain​/\_search | Ermittelt Daten von Domains die  im Bestand des Benutzers sind. |
| [Domain Premium List](/de/api/core-domain-premium-list/) | 165 | \- | Ermittelt Daten von Premium-Domains die im Bestand des Benutzers sind. |
| Domain Monitoring List | 155 | \- | Ermittelt  Daten mehrerer Domain-Überwachungen. |
| Job List | \- | POST​/job​/\_search | Ermittelt  Daten mehrerer Aufträgen. in XML Objektspetifische Job-Auftragstypen, z. B. DomainJobList, ZoneJobList, ContactJobList. |
| [MailProxyList](/de/api/core-mailproxy-list/) | 514 | POST /mailProxy/\_search | Ermittelt MailProxy-Daten mehrerer Domain. |
| [Redirect List](/de/api/core-redirect-list/) | 504 | POST /redirect/\_search | Ermittelt Daten der aktuellen Weiterleitungen. |
| SSLContact List | 400205 | POST /sslcontaxt/{id} | Ermittelt die Daten von SSL-Kontakten. |
| Transfer Out List | 106001 | POST /transferout/\_search | Ermittelt Daten mehrerer laufender ausgehender Transfers. |
| [Zone List](/de/api/core-zone-list/) | 205 | POST/zone/\_search | Ermittelt  Zonen-Daten mehrerer Zonen auf den vom System verwalteten Nameservern. |
| Zone History List | 225 | POST /zone/history/\_search | Ermittelt  Daten mehrerer Zonen |

## Weitere Details abfragen

In **XML** können mit dem Keyword <key> zusätzliche Details ermittelt werden.  Dafür muss unterhalb des Tags <task> ein Tag <key> hinzugefügt werden. Bei der Beschreibung der einzelnen Listenabfragen werden jeweils die Keywords angegeben, die mit  <key> abgefragt werden können.

```
<task>
       <key>created</key>
</task>
```

Analog können weitere Details in **JSON**  mithilfe von Query-Parameter abgefragt werden. Je nach Art der abgefragten Objekte können unterschiedliche Parameter verwendet werden. Die für die jeweilige Listenabfrage gültigen Parameter sind in der [Technischen Dokumentation für JSON](/en/api/core-json-technical-documentation/) hinterlegt.

```
POST /domain/_search?keys[]=$key1&keys[]=$key2
```

## Mögliche Operatoren für die Listenabfrage

|  |  |  |
| --- | --- | --- |
| **Wert JSON** | **Wert XML** | **Bedeutung** |
| EQUAL | eq | Direkter Vergleich (=) |
| NOT\_EQUAL | ne | Ist nicht (!=) |
| LIKE | like | Wildcard-Suche mit "\*", Groß- und Kleinschreibung beachten |
| GREATER | gt | Größer als (>) |
| LESS | lt | Kleiner als (<) |
| GREATER\_EQUAL | ge | Größer gleich (>=) |
| LESS\_EQUAL | le | Kleiner gleich (<=) |
| NOT\_LIKE | not\_like | Wildcard-Suche mit "\*", "Ist nicht gleich", Groß- und Kleinschreibung beachten |
| ILIKE | ilike | Wildcard-Suche mit "\*", "Ist gleich", Groß-/Kleinschreibung wird nicht berücksichtigt |

## Komplexe Abfragen

Mit Hilfe des Element [_Where_](/de/api/core-objekt-where/) sind komplexere Abfragen möglich. Es können mehrere Bedingungen mit **und**/**oder** verknüpft werden. Um mehrere Bedingungen z. B. mit **Und** zu verknüpfen, muss unterhalb des Tags **where** ein **and**\-Tag eröffnet werden. Unter diesem Tag werden nun für jede Bedingung  weitere **and**\-Tags eröffnet und darunter mit **key**, **operator** und **value** die Bedingung definiert, wie beim Beispiel 3 im Abschnitt Beispiele. Das gleiche gilt auch für reine **oder**\-Verknüpfungen wie im Beispiel 4 im Abschnitt Beispiele Beide Verknüpfungsarten können auch kombiniert werden.

### Beispiele für komplexe Abfragen in  JSON und XML

#### Beispiel 1: Einfache Abfrage mit "where"

```
{
    "filters": [
        {
            "key": "name",
            "operator": "LIKE",
            "value": "%json-test%"
        }
    ],
    "view": {
        "children": 1,
        "limit": 10
    },
    "orders": [
        {
            "key": "created",
            "type": "ASC"
        }
    ]
}
```

####  Beispiel 2: Komplexe Abfrage mit mehreren Bedingungen, die mit "Und" verknüpft sind

```
   {
    "filters": [
        {
            "key": "name",
            "operator": "LIKE",
            "value": "%json-test%"
        },
        {
            "key": "trustee",
            "operator": "EQUAL",
            "value": false
        }
    ],
    "view": {
        "children": 1,
        "limit": 10
    },
    "orders": [
        {
            "key": "created",
            "type": "ASC"
        }
    ]
}
```

####  Beispiel 3: Komplexe Abfrage mit mehreren Bedingungen, die mit "Oder" verknüpft sind

```
{
    "filters": [
        {
			"link": "OR",
            "filters": [
        		{
            		"key": "name",
            		"operator": "LIKE",
            		"value": "%json-test%"
        		},
	        	{
            		"key": "trustee",
            		"operator": "EQUAL",
            		"value": false
        		}
			]
        }
    ],
    "view": {
        "children": 1,
        "limit": 10
    },
    "orders": [
        {
            "key": "created",
            "type": "ASC"
        }
    ]
}
```

#### Beispiel 4: Komplexe Abfrage mit mit mehreren Bedingungen, die mit "Und" und "Oder"-Bedingungen verknüpft sind

```
{
    "filters": [
        {
            "link": "OR",
            "filters": [
                {
                    "key": "name",
                    "operator": "LIKE",
                    "value": "%json-test%"
                },
                {
					"link": "AND",
					"filters": [
						{
                      		"key": "comment",
                    		"operator": "LIKE",
                    		"value": "%on2%"
						},
						{
                      		"key": "create",
                    		"operator": "gt",
                    		"value": "2018-01-01 00:00:00"
						}
					]
                }
            ]
        },
        {
            "key": "trustee",
            "operator": "EQUAL",
            "value": false
        }
    ],
    "view": {
        "children": 1,
        "limit": 10
    },
    "orders": [
        {
            "key": "created",
            "type": "ASC"
        }
    ]
}
```

#### Beispiel 1: Einfache Abfrage mit "where"

```
<request>
    <auth>
        <user>USER</user>
        <password>PASSWORD</password>
        <context>CONTEXT</context>
    </auth>
    <task>
        <code>0105</code>
        <view>
            <limit>10</limit>
            <offset>0</offset>
            <children>0</children>
        </view>
        <where>
            <key>name</key>
            <operator>eq</operator>
            <value>example.com</value>
        </where>
        <order>
            <key>created</key>
            <mode>desc</mode>
        </order>
        <key>comment</key>
    </task>
</request>
```

#### Beispiel 2: Abfrage mit "where", der Limitierung der Ergebnisse mit "limit" und einer Sortierung mit "order"

Die Liste soll die ersten 30 Domains (offset = 0, limit = 30) die mit "a" anfangen (name like a\*) anzeigen. Zusätzlich wird das Feld _created_ angefordert (key = created).

```
 <request>
       <auth>
             <user>customer</user>
             <password>password</password>
             <context>4</context>
       </auth>
       <task>
             <code>0105</code>
             <view>
                    <offset>0</offset>
                    <limit>30</limit>
                    <children>1</children>
             </view>
             <key>created</key>
             <where>
                    <key>name</key>
                    <operator>like</operator>
                    <value>a*</value>
             </where>
             <order>
                    <key>created</key>
                    <mode>asc</mode>
             </order>
       </task>
 </request>
```

#### Beispiel 3: Komplexe Abfrage mit "where" und "and"

```
<request>
    <auth>
        <user>USER</user>
        <password>PASSWORD</password>
        <context>CONTEXT</context>
    </auth>
    <task>
        <code>0105</code>
        <view>
            <limit>10</limit>
            <offset>0</offset>
            <children>0</children>
        </view>
        <where>
            <and>
                <and>
                    <key>expire</key>
                    <operator>gt</operator>
                    <value>2018-06-01 00:00:00</value>
                </and>
                <and>
                    <key>expire</key>
                    <operator>lt</operator>
                    <value>2018-12-31 00:00:00</value>
                </and>
            </and>
        </where>
        <order>
            <key>expire</key>
            <mode>asc</mode>
        </order>
    </task>
</request>
```

#### Beispiel 4: Komplexe Abfrage mit "where" und "or"

```
<request>
    <auth>
        <user>USER</user>
        <password>PASSWORD</password>
        <context>CONTEXT</context>
    </auth>
    <task>
        <code>0105</code>
        <where>
         <or>
            <key>name</key>
            <operator>LIKE</operator>
            <value>json-test</value>
    
         </or>
         <or>
            <and>
                <key>comment</key>
                <operator>LIKE</operator>
                <value>on2</value>
            </and>
            <and>
                <key>created</key>
                <operator>gt</operator>
                <value>2020-05-01 00:00:00</value>
            </and>
         </or>
        </where>
        <order>
            <key>expire</key>
            <mode>asc</mode>
        </order>
    </task>
<request>
```