**Avis de fin de support :** le 30 octobre 2026, le support d'Amazon Pinpoint AWS prendra fin. Après le 30 octobre 2026, vous ne pourrez plus accéder à la console Amazon Pinpoint ni aux ressources Amazon Pinpoint (points de terminaison, segments, campagnes, parcours et analytique). Pour plus d’informations, consultez [Fin de la prise en charge d’Amazon Pinpoint](https://docs.aws.amazon.com/console/pinpoint/migration-guide). **Remarque :** en ce qui APIs concerne les SMS, la voix, le push mobile, l'OTP et la validation des numéros de téléphone ne sont pas concernés par cette modification et sont pris en charge par AWS la messagerie utilisateur final.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Importer des points de terminaison dans Amazon Pinpoint
<a name="audience-define-import"></a>

Vous pouvez ajouter ou mettre à jour des points de terminaison en nombre en les important à partir d'un compartiment Amazon S3. L'importation de points de terminaison est utile si vous disposez d'enregistrements sur votre audience en dehors d'Amazon Pinpoint, et si vous souhaitez ajouter ces informations à un projet Amazon Pinpoint. Dans ce cas, vous devez :

1. Créer des définitions de point de terminaison basées sur les données de votre propre public.

1. Enregistrez ces définitions de point de terminaison dans un ou plusieurs fichiers, et chargez les fichiers dans un compartiment Amazon S3.

1. Ajoutez les points de terminaison à votre projet Amazon Pinpoint en les important à partir du compartiment.

Chaque tâche d'importation peut transférer jusqu'à 1 Go de données. Lors d'une tâche courante, au cours de laquelle chaque point de terminaison a une taille inférieure ou égale à 4 Ko, vous pouvez importer environ 250 000 points de terminaison. Vous pouvez exécuter jusqu'à deux tâches d'importation simultanées par AWS compte. Si vous avez besoin de plus de bande passante pour vos tâches d'importation, vous pouvez envoyer une demande d'augmentation du quota de service à Support. Pour de plus amples informations, veuillez consulter [Demande d’augmentation de quota](quotas.md#quotas-increase).

## Avant de commencer
<a name="audience-define-import-before"></a>

Avant de pouvoir importer des points de terminaison, vous devez disposer des ressources suivantes dans votre compte AWS  :
+ Un compartiment Amazon S3. Pour créer un compartiment, consultez la section [Créer un compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html) dans le *Guide de l'utilisateur Amazon Simple Storage Service*.
+ Rôle Gestion des identités et des accès AWS (IAM) qui accorde à Amazon Pinpoint des autorisations de lecture pour votre compartiment Amazon S3. Pour créer ce rôle, consultez [Rôle IAM pour l'importation de points de terminaison ou de segments](permissions-import-segment.md).

## Exemples
<a name="audience-define-import-examples"></a>

Les exemples suivants expliquent comment ajouter des définitions de point de terminaison à votre compartiment Amazon S3, puis comment les importer dans un projet Amazon Pinpoint.

### Fichiers avec définitions de point de terminaison
<a name="audience-define-import-examples-files"></a>

Les fichiers que vous ajoutez à votre compartiment Amazon S3 peuvent contenir des définitions de point de terminaison au format CSV ou JSON délimité par des nouvelles lignes. Pour connaître les attributs que vous pouvez utiliser pour définir vos points de terminaison, consultez le schéma [EndpointRequest](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-endpoints-endpoint-id.html#apps-application-id-endpoints-endpoint-id-schemas)JSON dans le manuel *Amazon Pinpoint* API Reference.

------
#### [ CSV ]

Vous pouvez importer des points de terminaison définis dans un fichier CSV, comme dans l'exemple suivant :

```
ChannelType,Address,Location.Country,Demographic.Platform,Demographic.Make,User.UserId
SMS,12065550182,CN,Android,LG,example-user-id-1
APNS,1a2b3c4d5e6f7g8h9i0j1a2b3c4d5e6f,US,iOS,Apple,example-user-id-2
EMAIL,john.stiles@example.com,US,iOS,Apple,example-user-id-2
```

La première ligne est l'en-tête, qui contient les attributs de point de terminaison. Spécifiez les attributs imbriqués à l'aide de la notation de points, comme dans `Location.Country`.

Les lignes suivantes définissent les points de terminaison en fournissant les valeurs de chacun des attributs de l'en-tête.

Pour inclure une virgule ou un guillemet double dans une valeur, placez la valeur entre guillemets doubles, comme dans `"aaa,bbb"`.

Les sauts de ligne ne sont pas pris en charge au sein d'une valeur du CSV.

------
#### [ JSON ]

Vous pouvez importer des points de terminaison définis dans un fichier JSON délimité par des nouvelles lignes, comme dans l'exemple suivant :

```
{"ChannelType":"SMS","Address":"12065550182","Location":{"Country":"CN"},"Demographic":{"Platform":"Android","Make":"LG"},"User":{"UserId":"example-user-id-1"}}
{"ChannelType":"APNS","Address":"1a2b3c4d5e6f7g8h9i0j1a2b3c4d5e6f","Location":{"Country":"US"},"Demographic":{"Platform":"iOS","Make":"Apple"},"User":{"UserId":"example-user-id-2"}}
{"ChannelType":"EMAIL","Address":"john.stiles@example.com","Location":{"Country":"US"},"Demographic":{"Platform":"iOS","Make":"Apple"},"User":{"UserId":"example-user-id-2"}}
```

Dans ce cas, chaque ligne est un objet JSON complet qui contient une définition de point de terminaison distincte.

------

### Demandes de tâche d'importation
<a name="audience-define-import-examples-jobs"></a>

Les exemples suivants vous indiquent comment ajouter des définitions de point de terminaison à Amazon S3 en chargeant un fichier local dans un compartiment. Ensuite, les exemples importent les définitions de point de terminaison dans un projet Amazon Pinpoint.

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

Vous pouvez utiliser Amazon Pinpoint en exécutant des commandes avec l' AWS CLI.

**Example Commande CP S3**  
Pour charger un fichier local dans un compartiment Amazon S3, utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) d'Amazon S3 :  

```
$ aws s3 cp ./endpoints-file s3://bucket-name/prefix/
```

Où :
+ *./endpoints-file* correspond au chemin d'accès à un fichier local qui contient les définitions de point de terminaison.
+ *bucket-name/prefix/* correspond au nom de votre compartiment Amazon S3 et, éventuellement, un préfixe vous permettant d'organiser les objets de votre compartiment de manière hiérarchique. Par exemple, un préfixe utile peut être `pinpoint/imports/endpoints/`.

**Example Commande de création d'une tâche d'importation**  
Pour importer des définitions de points de terminaison à partir d'un compartiment Amazon S3, utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/pinpoint/create-import-job.html](https://docs.aws.amazon.com/cli/latest/reference/pinpoint/create-import-job.html) :  

```
$ aws pinpoint create-import-job \
> --application-id application-id \
> --import-job-request \
> S3Url=s3://bucket-name/prefix/key,\
> RoleArn=iam-import-role-arn,\
> Format=format,\
> RegisterEndpoints=true
```
Où :  
+ *application-id* correspond à l'ID du projet Amazon Pinpoint pour lequel vous importez des points de terminaison.
+ *bucket- name/prefix/key* est l'emplacement dans Amazon S3 qui contient un ou plusieurs objets à importer. L'emplacement peut se terminer par la clé d'un objet individuel, ou il peut se terminer par un préfixe qui qualifie plusieurs objets.
+ *iam-import-role-arn*est le nom de ressource Amazon (ARN) d'un rôle IAM qui accorde à Amazon Pinpoint un accès en lecture au bucket.
+ *format* peut être `JSON` ou `CSV`, selon le format utilisé pour définir vos points de terminaison. Si l'emplacement Amazon S3 inclut plusieurs objets de formats mixtes, Amazon Pinpoint importe uniquement les objets correspondant au format spécifié.
+ *RegisterEndpoints* peut avoir la valeur `true` ou `false`. Lorsque le paramètre est défini sur true, la tâche d'importation enregistre les points de terminaison auprès d'Amazon Pinpoint, lorsque les définitions de points de terminaison sont importées.  
**RegisterEndpoints et DefineSegments combinaisons**    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/pinpoint/latest/developerguide/audience-define-import.html)
La réponse inclut des détails sur la tâche d'importation :  

```
{
    "ImportJobResponse": {
        "CreationDate": "2018-05-24T21:26:33.995Z",
        "Definition": {
            "DefineSegment": false,
            "ExternalId": "463709046829",
            "Format": "JSON",
            "RegisterEndpoints": true,
            "RoleArn": "iam-import-role-arn",
            "S3Url": "s3://bucket-name/prefix/key"
        },
        "Id": "d5ecad8e417d498389e1d5b9454d4e0c",
        "JobStatus": "CREATED",
        "Type": "IMPORT"
    }
}
```
La réponse fournit l’ID de tâche avec l’attribut `Id`. Vous pouvez utiliser cet ID pour vérifier le statut actuel de la tâche d'importation.

**Example Commande de génération d'une tâche d'importation**  
Pour vérifier le statut actuel d'une tâche d'importation, utilisez la commande `get-import-job` :  

```
$ aws pinpoint get-import-job \
> --application-id application-id \
> --job-id job-id
```
Où :  
+ *application-id* correspond à l'ID du projet Amazon Pinpoint pour lequel la tâche d'importation a été initiée.
+ *job-id* correspond à l'ID de la tâche d'importation que vous vérifiez.
La réponse à cette commande fournit l'état actuel de la tâche d'importation :  

```
{
    "ImportJobResponse": {
        "ApplicationId": "application-id",
        "CompletedPieces": 1,
        "CompletionDate": "2018-05-24T21:26:45.308Z",
        "CreationDate": "2018-05-24T21:26:33.995Z",
        "Definition": {
            "DefineSegment": false,
            "ExternalId": "463709046829",
            "Format": "JSON",
            "RegisterEndpoints": true,
            "RoleArn": "iam-import-role-arn",
            "S3Url": "s3://s3-bucket-name/prefix/endpoint-definitions.json"
        },
        "FailedPieces": 0,
        "Id": "job-id",
        "JobStatus": "COMPLETED",
        "TotalFailures": 0,
        "TotalPieces": 1,
        "TotalProcessed": 3,
        "Type": "IMPORT"
    }
}
```
La réponse fournit le statut de la tâche avec l’attribut `JobStatus`.

------
#### [ AWS SDK pour Java ]

Vous pouvez utiliser l'API Amazon Pinpoint dans vos applications Java en utilisant le client fourni par AWS SDK pour Java.

**Example Code**  
Pour charger un fichier avec des définitions de point de terminaison dans Amazon S3, utilisez la méthode `putObject` du client `AmazonS3`.   
Pour importer les points de terminaison dans un projet Amazon Pinpoint, initialisez un objet `CreateImportJobRequest`. Transmettez ensuite cet objet à la méthode `createImportJob` du client `AmazonPinpoint`.  

```
package com.amazonaws.examples.pinpoint;

import com.amazonaws.AmazonServiceException;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.pinpoint.AmazonPinpoint;
import com.amazonaws.services.pinpoint.AmazonPinpointClientBuilder;
import com.amazonaws.services.pinpoint.model.CreateImportJobRequest;
import com.amazonaws.services.pinpoint.model.CreateImportJobResult;
import com.amazonaws.services.pinpoint.model.Format;
import com.amazonaws.services.pinpoint.model.GetImportJobRequest;
import com.amazonaws.services.pinpoint.model.GetImportJobResult;
import com.amazonaws.services.pinpoint.model.ImportJobRequest;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.AmazonS3Exception;
import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class ImportEndpoints {

    public static void main(String[] args) {

        final String USAGE = "\n" +
                "ImportEndpoints - Adds endpoints to an Amazon Pinpoint application by: \n" +
                "1.) Uploading the endpoint definitions to an Amazon S3 bucket. \n" +
                "2.) Importing the endpoint definitions from the bucket to an Amazon Pinpoint " +
                "application.\n\n" +
                "Usage: ImportEndpoints <endpointsFileLocation> <s3BucketName> <iamImportRoleArn> " +
                "<applicationId>\n\n" +
                "Where:\n" +
                "  endpointsFileLocation - The relative location of the JSON file that contains the " +
                "endpoint definitions.\n" +
                "  s3BucketName - The name of the Amazon S3 bucket to upload the JSON file to. If the " +
                "bucket doesn't exist, a new bucket is created.\n" +
                "  iamImportRoleArn - The ARN of an IAM role that grants Amazon Pinpoint read " +
                "permissions to the S3 bucket.\n" +
                "  applicationId - The ID of the Amazon Pinpoint application to add the endpoints to.";

        if (args.length < 1) {
            System.out.println(USAGE);
            System.exit(1);
        }

        String endpointsFileLocation = args[0];
        String s3BucketName = args[1];
        String iamImportRoleArn = args[2];
        String applicationId = args[3];

        Path endpointsFilePath = Paths.get(endpointsFileLocation);
        File endpointsFile = new File(endpointsFilePath.toAbsolutePath().toString());
        uploadToS3(endpointsFile, s3BucketName);

        importToPinpoint(endpointsFile.getName(), s3BucketName, iamImportRoleArn, applicationId);

    }

    private static void uploadToS3(File endpointsFile, String s3BucketName) {

        // Initializes Amazon S3 client.
        final AmazonS3 s3 = AmazonS3ClientBuilder.defaultClient();

        // Checks whether the specified bucket exists. If not, attempts to create one.
        if (!s3.doesBucketExistV2(s3BucketName)) {
            try {
                s3.createBucket(s3BucketName);
                System.out.format("Created S3 bucket %s.\n", s3BucketName);
            } catch (AmazonS3Exception e) {
                System.err.println(e.getErrorMessage());
                System.exit(1);
            }
        }

        // Uploads the endpoints file to the bucket.
        String endpointsFileName = endpointsFile.getName();
        System.out.format("Uploading %s to S3 bucket %s . . .\n", endpointsFileName, s3BucketName);
        try {
            s3.putObject(s3BucketName, "imports/" + endpointsFileName, endpointsFile);
            System.out.println("Finished uploading to S3.");
        } catch (AmazonServiceException e) {
            System.err.println(e.getErrorMessage());
            System.exit(1);
        }
    }

    private static void importToPinpoint(String endpointsFileName, String s3BucketName,
            String iamImportRoleArn, String applicationId) {

        // The S3 URL that Amazon Pinpoint requires to find the endpoints file.
        String s3Url = "s3://" + s3BucketName + "/imports/" + endpointsFileName;

        // Defines the import job that Amazon Pinpoint runs.
        ImportJobRequest importJobRequest = new ImportJobRequest()
                .withS3Url(s3Url)
                .withRegisterEndpoints(true)
                .withRoleArn(iamImportRoleArn)
                .withFormat(Format.JSON);
        CreateImportJobRequest createImportJobRequest = new CreateImportJobRequest()
                .withApplicationId(applicationId)
                .withImportJobRequest(importJobRequest);

        // Initializes the Amazon Pinpoint client.
        AmazonPinpoint pinpointClient = AmazonPinpointClientBuilder.standard()
                .withRegion(Regions.US_EAST_1).build();

        System.out.format("Importing endpoints in %s to Amazon Pinpoint application %s . . .\n",
                endpointsFileName, applicationId);

        try {

            // Runs the import job with Amazon Pinpoint.
            CreateImportJobResult importResult = pinpointClient.createImportJob(createImportJobRequest);

            String jobId = importResult.getImportJobResponse().getId();
            GetImportJobResult getImportJobResult = null;
            String jobStatus = null;

            // Checks the job status until the job completes or fails.
            do {
                getImportJobResult = pinpointClient.getImportJob(new GetImportJobRequest()
                        .withJobId(jobId)
                        .withApplicationId(applicationId));
                jobStatus = getImportJobResult.getImportJobResponse().getJobStatus();
                System.out.format("Import job %s . . .\n", jobStatus.toLowerCase());
                TimeUnit.SECONDS.sleep(3);
            } while (!jobStatus.equals("COMPLETED") && !jobStatus.equals("FAILED"));

            if (jobStatus.equals("COMPLETED")) {
                System.out.println("Finished importing endpoints.");
            } else {
                System.err.println("Failed to import endpoints.");
                System.exit(1);
            }

            // Checks for entries that failed to import.
            // getFailures provides up to 100 of the first failed entries for the job, if
            // any exist.
            List<String> failedEndpoints = getImportJobResult.getImportJobResponse().getFailures();
            if (failedEndpoints != null) {
                System.out.println("Failed to import the following entries:");
                for (String failedEndpoint : failedEndpoints) {
                    System.out.println(failedEndpoint);
                }
            }

        } catch (AmazonServiceException | InterruptedException e) {
            System.err.println(e.getMessage());
            System.exit(1);
        }

    }

}
```

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

Vous pouvez utiliser Amazon Pinpoint en effectuant des demandes HTTP directement à l'API REST.

**Example Demande PUT Object S3**  
Pour ajouter vos définitions de point de terminaison à un compartiment, utilisez l'opération Amazon S3 [PUT Object](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) et fournissez les définitions de point de terminaison en tant que corps :  

```
PUT /prefix/key HTTP/1.1
Content-Type: text/plain
Accept: application/json
Host: bucket-name.s3.amazonaws.com
X-Amz-Content-Sha256: c430dc094b0cec2905bc88d96314914d058534b14e2bc6107faa9daa12fdff2d
X-Amz-Date: 20180605T184132Z
Authorization: AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20180605/us-east-1/s3/aws4_request, SignedHeaders=accept;cache-control;content-length;content-type;host;postman-token;x-amz-content-sha256;x-amz-date, Signature=c25cbd6bf61bd3b3667c571ae764b9bf2d8af61b875cacced95d1e68d91b4170
Cache-Control: no-cache

{"ChannelType":"SMS","Address":"2065550182","Location":{"Country":"CAN"},"Demographic":{"Platform":"Android","Make":"LG"},"User":{"UserId":"example-user-id-1"}}
{"ChannelType":"APNS","Address":"1a2b3c4d5e6f7g8h9i0j1a2b3c4d5e6f","Location":{"Country":"USA"},"Demographic":{"Platform":"iOS","Make":"Apple"},"User":{"UserId":"example-user-id-2"}}
{"ChannelType":"EMAIL","Address":"john.stiles@example.com","Location":{"Country":"USA"},"Demographic":{"Platform":"iOS","Make":"Apple"},"User":{"UserId":"example-user-id-2"}}
```

Où :
+ */prefix/key* correspond au préfixe et au nom de clé de l'objet qui contient les définitions de point de terminaison après le chargement. Vous pouvez utiliser le préfixe pour organiser vos objets de manière hiérarchique. Par exemple, un préfixe utile peut être `pinpoint/imports/endpoints/`.
+ *bucket-name* correspond au nom du compartiment Amazon S3 auquel vous ajoutez les définitions de point de terminaison.

**Example Demande de tâche d'importation POST**  
Pour importer des définitions de points de terminaison à partir d'un compartiment Amazon S3, envoyez une demande POST à la ressource [Tâches d'importation](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-jobs-import.html). Dans votre demande, incluez les en-têtes requis et fournissez le [ImportJobRequest](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-jobs-import.html#apps-application-id-jobs-import-schemas)JSON comme corps :  

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

{
  "S3Url": "s3://bucket-name/prefix/key",
  "RoleArn": "iam-import-role-arn",
  "Format": "format",
  "RegisterEndpoints": true
}
```
Où :  
+ *application-id* correspond à l'ID du projet Amazon Pinpoint pour lequel vous importez des points de terminaison.
+ *bucket- name/prefix/key* est l'emplacement dans Amazon S3 qui contient un ou plusieurs objets à importer. L'emplacement peut se terminer par la clé d'un objet individuel, ou il peut se terminer par un préfixe qui qualifie plusieurs objets.
+ *iam-import-role-arn*est le nom de ressource Amazon (ARN) d'un rôle IAM qui accorde à Amazon Pinpoint un accès en lecture au bucket.
+ *format* peut être `JSON` ou `CSV`, selon le format utilisé pour définir vos points de terminaison. Si l'emplacement Amazon S3 inclut plusieurs fichiers de formats mixtes, Amazon Pinpoint importe uniquement les fichiers correspondant au format spécifié.
Si votre demande aboutit, vous recevez une réponse similaire à ce qui suit :  

```
{
    "Id": "a995ce5d70fa44adb563b7d0e3f6c6f5",
    "JobStatus": "CREATED",
    "CreationDate": "2018-06-05T21:49:15.288Z",
    "Type": "IMPORT",
    "Definition": {
        "S3Url": "s3://bucket-name/prefix/key",
        "RoleArn": "iam-import-role-arn",
        "ExternalId": "external-id",
        "Format": "JSON",
        "RegisterEndpoints": true,
        "DefineSegment": false
    }
}
```
La réponse fournit l’ID de tâche avec l’attribut `Id`. Vous pouvez utiliser cet ID pour vérifier le statut actuel de la tâche d'importation.

**Example Demande de tâche d'importation GET**  
Pour vérifier le statut actuel d'une tâche d'importation, envoyez une demande `GET` à la ressource [Tâche d'importation](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-jobs-import-job-id.html) :  

```
GET /v1/apps/application_id/jobs/import/job_id HTTP/1.1
Content-Type: application/json
Accept: application/json
Host: pinpoint.us-east-1.amazonaws.com
X-Amz-Date: 20180605T220744Z
Authorization: AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20180605/us-east-1/mobiletargeting/aws4_request, SignedHeaders=accept;cache-control;content-type;host;postman-token;x-amz-date, Signature=c25cbd6bf61bd3b3667c571ae764b9bf2d8af61b875cacced95d1e68d91b4170
Cache-Control: no-cache
```
Où :  
+ *application-id* correspond à l'ID du projet Amazon Pinpoint pour lequel la tâche d'importation a été initiée.
+ *job-id* correspond à l'ID de la tâche d'importation que vous vérifiez.
Si votre demande aboutit, vous recevez une réponse similaire à ce qui suit :  

```
{
    "ApplicationId": "application_id",
    "Id": "70a51b2cf442447492d2c8e50336a9e8",
    "JobStatus": "COMPLETED",
    "CompletedPieces": 1,
    "FailedPieces": 0,
    "TotalPieces": 1,
    "CreationDate": "2018-06-05T22:04:49.213Z",
    "CompletionDate": "2018-06-05T22:04:58.034Z",
    "Type": "IMPORT",
    "TotalFailures": 0,
    "TotalProcessed": 3,
    "Definition": {
        "S3Url": "s3://bucket-name/prefix/key.json",
        "RoleArn": "iam-import-role-arn",
        "ExternalId": "external-id",
        "Format": "JSON",
        "RegisterEndpoints": true,
        "DefineSegment": false
    }
}
```
La réponse fournit le statut de la tâche avec l’attribut `JobStatus`.

------

## Informations connexes
<a name="audience-define-import-related"></a>

Pour plus d'informations concernant la ressource Tâches d'importation dans l'API Amazon Pinpoint, notamment les méthodes HTTP prises en charge et les paramètres de demande, consultez [Tâches d'importation](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-jobs-import.html) dans la *Référence de l'API Amazon Pinpoint*.