# Ajouter un mot de passe à un PDF

Chiffrez un PDF pour qu’il exige un mot de passe à l’ouverture, en choisissant l’algorithme de chiffrement.

Chiffrez un document PDF avec un mot de passe d’ouverture pour qu’il ne puisse
pas être ouvert sans lui. Cette action définit le mot de passe exigé uniquement
pour ouvrir le fichier, à distinguer de [l’ajout de
restrictions](/docs/api/add-restrictions-to-pdf), qui définit des indicateurs
d’autorisation pour des actions comme l’impression et la copie. Choisissez
l’algorithme de chiffrement qui correspond à vos exigences de conformité. L’API
est *stateless* : votre document est traité dans la région et n’est jamais
stocké.

## Endpoint

<Endpoint method="POST" path="/v1/add_password" />

Disponible dans toutes les régions. Consultez [Régions et résidence des
données](/docs/api/regions-and-data-residency) pour le routage et la résidence
des données.

| Région           | URL                                               |
| ---------------- | ------------------------------------------------- |
| Global           | `https://api.pdfblocks.com/v1/add_password`       |
| États-Unis       | `https://us.api.pdfblocks.com/v1/add_password`    |
| HIPAA États-Unis | `https://hipaa.api.pdfblocks.com/v1/add_password` |
| Union européenne | `https://eu.api.pdfblocks.com/v1/add_password`    |
| Royaume-Uni      | `https://uk.api.pdfblocks.com/v1/add_password`    |
| Canada           | `https://ca.api.pdfblocks.com/v1/add_password`    |
| Australie        | `https://au.api.pdfblocks.com/v1/add_password`    |
| Japon            | `https://jp.api.pdfblocks.com/v1/add_password`    |
| Inde             | `https://in.api.pdfblocks.com/v1/add_password`    |
| Brésil           | `https://br.api.pdfblocks.com/v1/add_password`    |

## Authentification

Authentifiez chaque requête avec votre clé d’API secrète dans l’en-tête
`X-API-Key`, en HTTPS. Créez et gérez vos clés depuis le
[dashboard](https://dashboard.pdfblocks.com). Consultez
[Authentification](/docs/api/authentication) pour plus de détails.

## Requête

L’endpoint accepte un corps de requête `multipart/form-data`.

<ParamField name="file" type="file" required>
  Le document PDF d’entrée.
</ParamField>

<ParamField name="password" type="string" required>
  Le mot de passe exigé pour ouvrir le document. De 4 à 32 caractères ASCII
  imprimables (`^[\x20-\x7e]{4,32}$`).
</ParamField>

<ParamField name="encryption_algorithm" type="string" default="AES-128">
  L’algorithme de chiffrement : `AES-128` ou `AES-256`.
</ParamField>

<Note>
  Cette action définit le mot de passe d’ouverture, qui chiffre le document pour
  qu’il ne puisse pas être ouvert sans ce mot de passe. Pour limiter ce qu’un
  lecteur peut faire (imprimer, copier, modifier) sans exiger de mot de passe à
  l’ouverture, utilisez plutôt [Ajouter des restrictions à un
  PDF](/docs/api/add-restrictions-to-pdf). Pour le cycle de vie complet,
  consultez [Protéger et déverrouiller des
  documents](/docs/api/protecting-documents).
</Note>

## Exemples

Chiffrez un PDF avec AES-256 pour qu’il ne puisse pas être ouvert sans le mot
de passe :

<CodeGroup>

```bash title="cURL"
curl https://api.pdfblocks.com/v1/add_password \
  -H 'X-API-Key: your_api_key' \
  -F file=@input.pdf \
  -F password='0pen-Sesame' \
  -F encryption_algorithm=AES-256 \
  -o encrypted.pdf
```

```python title="Python"
# pip install requests
import requests

with open('input.pdf', 'rb') as file:
    response = requests.post(
        'https://api.pdfblocks.com/v1/add_password',
        headers={'X-API-Key': 'your_api_key'},
        files={'file': file},
        data={
            'password': '0pen-Sesame',
            'encryption_algorithm': 'AES-256',
        },
    )

response.raise_for_status()
with open('encrypted.pdf', 'wb') as output:
    output.write(response.content)
```

```javascript title="Node.js"
// Node.js 18+
import { readFile, writeFile } from 'node:fs/promises';

const body = new FormData();
body.set('file', new Blob([await readFile('input.pdf')]), 'input.pdf');
body.set('password', '0pen-Sesame');
body.set('encryption_algorithm', 'AES-256');

const response = await fetch('https://api.pdfblocks.com/v1/add_password', {
  method: 'POST',
  headers: { 'X-API-Key': 'your_api_key' },
  body,
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
await writeFile('encrypted.pdf', Buffer.from(await response.arrayBuffer()));
```

```php title="PHP"
<?php
$ch = curl_init('https://api.pdfblocks.com/v1/add_password');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['X-API-Key: your_api_key'],
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => [
        'file' => new CURLFile('input.pdf', 'application/pdf'),
        'password' => '0pen-Sesame',
        'encryption_algorithm' => 'AES-256',
    ],
]);

$pdf = curl_exec($ch);
if (curl_getinfo($ch, CURLINFO_HTTP_CODE) === 200) {
    file_put_contents('encrypted.pdf', $pdf);
}
```

```ruby title="Ruby"
# gem install http
require 'http'

response = HTTP
  .headers('X-API-Key' => 'your_api_key')
  .post('https://api.pdfblocks.com/v1/add_password', form: {
    file: HTTP::FormData::File.new('input.pdf'),
    password: '0pen-Sesame',
    encryption_algorithm: 'AES-256',
  })

File.write('encrypted.pdf', response.body) if response.status.success?
```

```go title="Go"
package main

import (
	"bytes"
	"io"
	"mime/multipart"
	"net/http"
	"os"
)

func main() {
	var buf bytes.Buffer
	form := multipart.NewWriter(&buf)

	file, _ := os.Open("input.pdf")
	defer file.Close()
	part, _ := form.CreateFormFile("file", "input.pdf")
	io.Copy(part, file)

	form.WriteField("password", "0pen-Sesame")
	form.WriteField("encryption_algorithm", "AES-256")
	form.Close()

	req, _ := http.NewRequest("POST", "https://api.pdfblocks.com/v1/add_password", &buf)
	req.Header.Set("Content-Type", form.FormDataContentType())
	req.Header.Set("X-API-Key", "your_api_key")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()

	out, _ := os.Create("encrypted.pdf")
	defer out.Close()
	io.Copy(out, res.Body)
}
```

```csharp title="C#"
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", "your_api_key");

using var form = new MultipartFormDataContent
{
    { new ByteArrayContent(File.ReadAllBytes("input.pdf")), "file", "input.pdf" },
    { new StringContent("0pen-Sesame"), "password" },
    { new StringContent("AES-256"), "encryption_algorithm" },
};

var response = await client.PostAsync(
    "https://api.pdfblocks.com/v1/add_password", form);
response.EnsureSuccessStatusCode();
await File.WriteAllBytesAsync(
    "encrypted.pdf", await response.Content.ReadAsByteArrayAsync());
```

</CodeGroup>

## Réponse

En cas de succès, la réponse est un `200 OK` dont le corps contient le PDF
chiffré :

```http
HTTP/1.1 200 OK
Content-Type: application/pdf
Content-Length: 48213
```

La sortie est le même document, désormais chiffré : ses pages et son contenu
sont inchangés. Écrivez le corps directement dans un fichier, comme le font les
exemples ci-dessus ; rien n’est stocké de notre côté.

## Erreurs

Les requêtes en échec renvoient un corps `application/problem+json`. La plus
courante pour cet endpoint est une `400`, renvoyée lorsqu’un paramètre est
invalide, par exemple un `password` qui ne fait pas de 4 à 32 caractères ASCII
imprimables, avec l’objet `errors` qui nomme chaque champ :

```json
{
  "type": "https://www.pdfblocks.com/docs/api/v1/error/400",
  "title": "One or more validation errors occurred.",
  "status": 400,
  "errors": {
    "password": ["The field password must match the regular expression '^[\\x20-\\x7e]{4,32}$'."]
  }
}
```

Une `X-API-Key` manquante ou invalide renvoie une `401`. Consultez
[Erreurs](/docs/api/errors) pour tous les codes de statut et la forme complète
de la réponse.

## Recettes

Variantes courantes. Dépliez-en une pour la voir dans tous les langages.

<AccordionGroup>

<Accordion title="Chiffrer avec AES-128, l’algorithme par défaut">

<CodeGroup>

```bash title="cURL"
curl https://api.pdfblocks.com/v1/add_password \
  -H 'X-API-Key: your_api_key' \
  -F file=@input.pdf \
  -F password='Tr0ub4dor' \
  -o encrypted.pdf
```

```python title="Python"
import requests

with open('input.pdf', 'rb') as file:
    response = requests.post(
        'https://api.pdfblocks.com/v1/add_password',
        headers={'X-API-Key': 'your_api_key'},
        files={'file': file},
        data={'password': 'Tr0ub4dor'},
    )

response.raise_for_status()
with open('encrypted.pdf', 'wb') as output:
    output.write(response.content)
```

```javascript title="Node.js"
import { readFile, writeFile } from 'node:fs/promises';

const body = new FormData();
body.set('file', new Blob([await readFile('input.pdf')]), 'input.pdf');
body.set('password', 'Tr0ub4dor');

const response = await fetch('https://api.pdfblocks.com/v1/add_password', {
  method: 'POST',
  headers: { 'X-API-Key': 'your_api_key' },
  body,
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
await writeFile('encrypted.pdf', Buffer.from(await response.arrayBuffer()));
```

```php title="PHP"
<?php
$ch = curl_init('https://api.pdfblocks.com/v1/add_password');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['X-API-Key: your_api_key'],
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => [
        'file' => new CURLFile('input.pdf', 'application/pdf'),
        'password' => 'Tr0ub4dor',
    ],
]);

$pdf = curl_exec($ch);
if (curl_getinfo($ch, CURLINFO_HTTP_CODE) === 200) {
    file_put_contents('encrypted.pdf', $pdf);
}
```

```ruby title="Ruby"
require 'http'

response = HTTP
  .headers('X-API-Key' => 'your_api_key')
  .post('https://api.pdfblocks.com/v1/add_password', form: {
    file: HTTP::FormData::File.new('input.pdf'),
    password: 'Tr0ub4dor',
  })

File.write('encrypted.pdf', response.body) if response.status.success?
```

```go title="Go"
package main

import (
	"bytes"
	"io"
	"mime/multipart"
	"net/http"
	"os"
)

func main() {
	var buf bytes.Buffer
	form := multipart.NewWriter(&buf)

	file, _ := os.Open("input.pdf")
	defer file.Close()
	part, _ := form.CreateFormFile("file", "input.pdf")
	io.Copy(part, file)

	form.WriteField("password", "Tr0ub4dor")
	form.Close()

	req, _ := http.NewRequest("POST", "https://api.pdfblocks.com/v1/add_password", &buf)
	req.Header.Set("Content-Type", form.FormDataContentType())
	req.Header.Set("X-API-Key", "your_api_key")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()

	out, _ := os.Create("encrypted.pdf")
	defer out.Close()
	io.Copy(out, res.Body)
}
```

```csharp title="C#"
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", "your_api_key");

using var form = new MultipartFormDataContent
{
    { new ByteArrayContent(File.ReadAllBytes("input.pdf")), "file", "input.pdf" },
    { new StringContent("Tr0ub4dor"), "password" },
};

var response = await client.PostAsync(
    "https://api.pdfblocks.com/v1/add_password", form);
response.EnsureSuccessStatusCode();
await File.WriteAllBytesAsync(
    "encrypted.pdf", await response.Content.ReadAsByteArrayAsync());
```

</CodeGroup>

</Accordion>

</AccordionGroup>

## Actions associées

<CardGroup cols={2}>

<Card title="Supprimer le mot de passe" href="/docs/api/remove-password-from-pdf">
  Déchiffrer un PDF protégé par mot de passe.
</Card>

<Card title="Ajouter des restrictions" href="/docs/api/add-restrictions-to-pdf">
  Définir des indicateurs d’autorisation plutôt qu’un mot de passe d’ouverture.
</Card>

<Card title="Supprimer les restrictions" href="/docs/api/remove-restrictions-from-pdf">
  Effacer les indicateurs d’autorisation.
</Card>

<Card title="Ajouter un filigrane texte" href="/docs/api/add-text-watermark-to-pdf">
  Apposer un filigrane sur le document avant de le chiffrer.
</Card>

</CardGroup>