

**Hinweis zum Ende des Supports:** Am 30. Oktober 2026 AWS wird der Support für Amazon Pinpoint eingestellt. Nach dem 30. Oktober 2026 können Sie nicht mehr auf die Amazon-Pinpoint-Konsole oder die Amazon-Pinpoint-Ressourcen (Endpunkte, Segmente, Kampagnen, Journeys und Analytik) zugreifen. Weitere Informationen finden Sie unter [Ende des Amazon-Pinpoint-Supports](https://docs.aws.amazon.com/console/pinpoint/migration-guide). **Hinweis:** APIs In Bezug auf SMS sind Sprach-, mobile Push-, OTP- und Telefonnummernvalidierung von dieser Änderung nicht betroffen und werden von AWS End User Messaging unterstützt.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Eine Reihe von Endpunkten zu Amazon Pinpoint hinzufügen
<a name="audience-define-endpoints-batch"></a>

Sie können mehrere Endpunkte in einer einzigen Operation hinzufügen oder aktualisieren, indem Sie die Endpunkte in Stapeln übergeben. Jede Stapelanforderung kann bis zu 100 Endpunktdefinitionen enthalten.

Wenn Sie mehr als 100 Endpunkte in einer einzigen Operation hinzufügen oder aktualisieren möchten, lesen Sie stattdessen unter [Endpunkte in Amazon Pinpoint importieren](audience-define-import.md) nach.

## Beispiele
<a name="audience-define-endpoints-batch-examples"></a>

Die folgenden Beispiele zeigen Ihnen, wie Sie zwei Endpunkte auf einmal hinzufügen, indem Sie die Endpunkte in eine Stapelanforderung aufnehmen.

------
#### [ AWS CLI ]

Sie können Amazon Pinpoint verwenden, indem Sie Befehle mit der AWS CLI ausführen.

**Example Befehl zum Aktualisieren von Endpunktstapeln**  
Um eine Endpunkt-Stapelanforderung zu senden, verwenden Sie den Befehl [https://docs.aws.amazon.com/cli/latest/reference/pinpoint/update-endpoints-batch.html](https://docs.aws.amazon.com/cli/latest/reference/pinpoint/update-endpoints-batch.html):  

```
$ aws pinpoint update-endpoints-batch \
> --application-id application-id \
> --endpoint-batch-request file://endpoint_batch_request_file.json
```
Wobei Folgendes gilt:  
+ *application-id*ist die ID des Amazon Pinpoint Pinpoint-Projekts, in dem Sie die Endpunkte hinzufügen oder aktualisieren.
+ *endpoint\$1batch\$1request\$1file.json*ist der Dateipfad zu einer lokalen JSON-Datei, die die Eingabe für den `--endpoint-batch-request` Parameter enthält.

**Example Endpunktstapel-Anforderungsdatei**  
Der Beispielbefehl `update-endpoints-batch` verwendet eine JSON-Datei als Argument für den Parameter `--endpoint-request`. Diese Datei enthält einen Stapel von Endpunktdefinitionen wie die folgenden:  

```
{
    "Item": [
        {
            "ChannelType": "EMAIL",
            "Address": "richard_roe@example.com",
            "Attributes": {
                "Interests": [
                    "Music",
                    "Books"
                ]
            },
            "Metrics": {
                "music_interest_level": 3.0,
                "books_interest_level": 7.0
            },
            "Id": "example_endpoint_1",
            "User":{
                "UserId": "example_user_1",
                "UserAttributes": {
                    "FirstName": "Richard",
                    "LastName": "Roe"
                }
            }
        },
        {
            "ChannelType": "SMS",
            "Address": "+16145550100",
            "Attributes": {
                "Interests": [
                    "Cooking",
                    "Politics",
                    "Finance"
                ]
            },
            "Metrics": {
                "cooking_interest_level": 5.0,
                "politics_interest_level": 8.0,
                "finance_interest_level": 4.0
            },
            "Id": "example_endpoint_2",
            "User": {
                "UserId": "example_user_2",
                "UserAttributes": {
                    "FirstName": "Mary",
                    "LastName": "Major"
                }
            }
        }
    ]
}
```
Informationen zu den Attributen, mit denen Sie einen Stapel von Endpunkten definieren können, finden Sie im [EndpointBatchRequest](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-endpoints.html#apps-application-id-endpoints-schemas)Schema in der *Amazon Pinpoint API-Referenz*.

------
#### [ AWS SDK für Java ]

Sie können die Amazon-Pinpoint-API in Ihren Java-Anwendungen verwenden, indem Sie den vom AWS SDK für Java bereitgestellten Client verwenden.

**Example Code**  
Um eine Endpunkt-Stapelanforderung zu senden, initialisieren Sie ein `EndpointBatchRequest`-Objekt und übergeben es der Methode `updateEndpointsBatch` des `AmazonPinpoint`-Clients. Das folgende Beispiel füllt ein `EndpointBatchRequest`-Objekt mit zwei `EndpointBatchItem`-Objekten:  

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.pinpoint.PinpointClient;
import software.amazon.awssdk.services.pinpoint.model.UpdateEndpointsBatchResponse;
import software.amazon.awssdk.services.pinpoint.model.EndpointUser;
import software.amazon.awssdk.services.pinpoint.model.EndpointBatchItem;
import software.amazon.awssdk.services.pinpoint.model.ChannelType;
import software.amazon.awssdk.services.pinpoint.model.EndpointBatchRequest;
import software.amazon.awssdk.services.pinpoint.model.PinpointException;
import software.amazon.awssdk.services.pinpoint.model.UpdateEndpointsBatchRequest;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
```

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.pinpoint.PinpointClient;
import software.amazon.awssdk.services.pinpoint.model.UpdateEndpointsBatchResponse;
import software.amazon.awssdk.services.pinpoint.model.EndpointUser;
import software.amazon.awssdk.services.pinpoint.model.EndpointBatchItem;
import software.amazon.awssdk.services.pinpoint.model.ChannelType;
import software.amazon.awssdk.services.pinpoint.model.EndpointBatchRequest;
import software.amazon.awssdk.services.pinpoint.model.PinpointException;
import software.amazon.awssdk.services.pinpoint.model.UpdateEndpointsBatchRequest;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class AddExampleEndpoints {

        public static void main(String[] args) {
                final String usage = """

                                Usage:    <appId>

                                Where:
                                   appId - The ID of the application.

                                """;

                if (args.length != 1) {
                        System.out.println(usage);
                        System.exit(1);
                }

                String applicationId = args[0];
                PinpointClient pinpoint = PinpointClient.builder()
                                .region(Region.US_EAST_1)
                                .build();

                updateEndpointsViaBatch(pinpoint, applicationId);
                pinpoint.close();
        }

        public static void updateEndpointsViaBatch(PinpointClient pinpoint, String applicationId) {
                try {
                        List<String> myList = new ArrayList<>();
                        myList.add("music");
                        myList.add("books");

                        Map myMap = new HashMap<String, List>();
                        myMap.put("attributes", myList);

                        List<String> myNames = new ArrayList<String>();
                        myList.add("Richard");
                        myList.add("Roe");

                        Map myMap2 = new HashMap<String, List>();
                        myMap2.put("name", myNames);

                        EndpointUser richardRoe = EndpointUser.builder()
                                        .userId("example_user_1")
                                        .userAttributes(myMap2)
                                        .build();

                        // Create an EndpointBatchItem object for Richard Roe.
                        EndpointBatchItem richardRoesEmailEndpoint = EndpointBatchItem.builder()
                                        .channelType(ChannelType.EMAIL)
                                        .address("richard_roe@example.com")
                                        .id("example_endpoint_1")
                                        .attributes(myMap)
                                        .user(richardRoe)
                                        .build();

                        List<String> myListMary = new ArrayList<String>();
                        myListMary.add("cooking");
                        myListMary.add("politics");
                        myListMary.add("finance");

                        Map myMapMary = new HashMap<String, List>();
                        myMapMary.put("interests", myListMary);

                        List<String> myNameMary = new ArrayList<String>();
                        myNameMary.add("Mary ");
                        myNameMary.add("Major");

                        Map maryName = new HashMap<String, List>();
                        myMapMary.put("name", myNameMary);

                        EndpointUser maryMajor = EndpointUser.builder()
                                        .userId("example_user_2")
                                        .userAttributes(maryName)
                                        .build();

                        // Create an EndpointBatchItem object for Mary Major.
                        EndpointBatchItem maryMajorsSmsEndpoint = EndpointBatchItem.builder()
                                        .channelType(ChannelType.SMS)
                                        .address("+16145550100")
                                        .id("example_endpoint_2")
                                        .attributes(myMapMary)
                                        .user(maryMajor)
                                        .build();

                        // Adds multiple endpoint definitions to a single request object.
                        EndpointBatchRequest endpointList = EndpointBatchRequest.builder()
                                        .item(richardRoesEmailEndpoint)
                                        .item(maryMajorsSmsEndpoint)
                                        .build();

                        // Create the UpdateEndpointsBatchRequest.
                        UpdateEndpointsBatchRequest batchRequest = UpdateEndpointsBatchRequest.builder()
                                        .applicationId(applicationId)
                                        .endpointBatchRequest(endpointList)
                                        .build();

                        // Updates the endpoints with Amazon Pinpoint.
                        UpdateEndpointsBatchResponse result = pinpoint.updateEndpointsBatch(batchRequest);
                        System.out.format("Update endpoints batch result: %s\n", result.messageBody().message());

                } catch (PinpointException e) {
                        System.err.println(e.awsErrorDetails().errorMessage());
                        System.exit(1);
                }
        }
}
```

Das vollständige SDK-Beispiel finden Sie unter [AddExampleEndpoints.java on. [GitHub](https://github.com/)](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/pinpoint/src/main/java/com/example/pinpoint/AddExampleEndpoints.java)

------
#### [ HTTP ]

Sie können Amazon Pinpoint verwenden, indem Sie HTTP-Anforderungen direkt an die REST-API stellen.

**Example Anforderung zum Ablegen von Endpunkten**  
Um eine Endpunkt-Stapelanforderung zu senden, stellen Sie eine `PUT`-Anforderung an die [Endpunkte](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-endpoints.html)-Ressource unter der folgenden URI:  
`/v1/apps/application-id/endpoints`  
Wo *application-id* ist die ID des Amazon Pinpoint Pinpoint-Projekts, in dem Sie die Endpunkte hinzufügen oder aktualisieren.  
Fügen Sie in Ihrer Anfrage die erforderlichen Header ein und geben Sie den [EndpointBatchRequest](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-endpoints.html#apps-application-id-endpoints-schemas)JSON-Code als Hauptteil an:  

```
PUT /v1/apps/application_id/endpoints HTTP/1.1
Host: pinpoint.us-east-1.amazonaws.com
Content-Type: application/json
Accept: application/json
X-Amz-Date: 20180501T184948Z
Authorization: AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20180501/us-east-1/mobiletargeting/aws4_request, SignedHeaders=accept;content-length;content-type;host;x-amz-date, Signature=c25cbd6bf61bd3b3667c571ae764b9bf2d8af61b875cacced95d1e68d91b4170
Cache-Control: no-cache

{
    "Item": [
        {
            "ChannelType": "EMAIL",
            "Address": "richard_roe@example.com",
            "Attributes": {
                "Interests": [
                    "Music",
                    "Books"
                ]
            },
            "Metrics": {
                "music_interest_level": 3.0,
                "books_interest_level": 7.0
            },
            "Id": "example_endpoint_1",
            "User":{
                "UserId": "example_user_1",
                "UserAttributes": {
                    "FirstName": "Richard",
                    "LastName": "Roe"
                }
            }
        },
        {
            "ChannelType": "SMS",
            "Address": "+16145550100",
            "Attributes": {
                "Interests": [
                    "Cooking",
                    "Politics",
                    "Finance"
                ]
            },
            "Metrics": {
                "cooking_interest_level": 5.0,
                "politics_interest_level": 8.0,
                "finance_interest_level": 4.0
            },
            "Id": "example_endpoint_2",
            "User": {
                "UserId": "example_user_2",
                "UserAttributes": {
                    "FirstName": "Mary",
                    "LastName": "Major"
                }
            }
        }
    ]
}
```
Wenn Ihre Anforderung erfolgreich ist, erhalten Sie eine Antwort wie die folgende:  

```
{
    "RequestID": "67e572ed-41d5-11e8-9dc5-db288f3cbb72",
    "Message": "Accepted"
}
```

------

## Ähnliche Informationen
<a name="audience-define-endpoints-batch-related"></a>

Weitere Informationen über die Endpunkt-Ressource in der Amazon-Pinpoint-API, einschließlich der unterstützten HTTP-Methoden und Anforderungsparameter, finden Sie unter [Endpunkt](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-endpoints-endpoint-id.html) in der *Amazon-Pinpoint-API-Referenz*.