Name: Encryption API: AES, DES, TripleDES Encrypt and Decrypt
Brand: zsmartsoft
SKU: api-zsmartsoft-encryption-api
Availability: InStock
Author: API Market

Ezzat Elbadrawy

# Encryption API

## Overview

The Encryption API encrypts and decrypts text and files with a secret key that you supply, using one of five symmetric algorithms (AES, DES, TripleDES, RC2 and Rijndael) and one of three cipher modes (CBC, which is the default, ECB and CFB). It has 8 endpoints in two matching sets. Four endpoints encrypt: text by GET query or JSON POST body, and files by multipart upload or as a raw byte body. Four endpoints decrypt the same way. Encrypted text comes back as a base64 string that you can pass straight to a decrypt endpoint, and encrypted files come back as raw bytes that you can send back to a file decrypt endpoint. To get the original data back, you must use the same secret key, algorithm and cipher mode that were used to encrypt it.

It is for developers who want to add symmetric encryption to an application, script or workflow without bundling a crypto library, for teams that need to read or produce data in older formats such as DES or TripleDES, and for anyone who wants to protect a file before storing or sending it. Text endpoints return a small JSON object with a `status` field (`Success` or `Failure`) and a `result` field that holds the base64 ciphertext, the decrypted text, or an error message. File endpoints return the encrypted or decrypted file itself as `application/octet-stream`.

## Features

*   **8 endpoints**: Encrypt text (GET and POST), encrypt a file (multipart and raw body), decrypt text (GET and POST) and decrypt a file (multipart and raw body).
*   **Flexible inputs**: Text as a query parameter or a JSON body, and files as a multipart form field or as the raw request body.
*   **Five algorithms**: `AES`, `DES`, `TripleDES`, `RC2` and `Rijndael`, chosen per request with `cryptAlgorithm`.
*   **Three cipher modes**: `CBC` (default), `ECB` and `CFB`, chosen with `cipherMode`.
*   **Your own key**: You pass the `secretKey` on each call, so the same key, algorithm and mode always decrypt what they encrypted.
*   **Base64 text output**: Encrypted text is returned as a base64 string inside `{"status":"Success","result":"..."}`.
*   **Verified round trips**: In our tests, text and file round trips returned the original data byte for byte with AES, TripleDES and DES, on both text and PDF files.
*   **Rate limit**: 5 requests per second on Free, 50 on Pro and 500 on Mega.

## Use Cases

*   **Encrypting fields before storage**: Encrypt a sensitive string, such as a note or token, before you save it to a database, and decrypt it when you read it back.
*   **Protecting files before upload**: Encrypt an invoice, PDF or export file before putting it in shared or cloud storage.
*   **Working with legacy formats**: Decrypt or produce data that an older system encrypted with DES or TripleDES.
*   **Low-code and scripting workflows**: Add encryption to automation tools or shell scripts that can make HTTP calls but cannot load a crypto library.
*   **Testing and interoperability**: Check that data encrypted by one system can be decrypted with the same key, algorithm and mode.

## API Documentation

### Base URL

All requests go through the API.market gateway at this base URL:

```
https://prod.api.market/api/v1/zsmartsoft/encryption-api
```

### Authentication

Every request needs your API.market key in the `x-api-market-key` header:

```
x-api-market-key: YOUR_API_KEY
```

Replace `YOUR_API_KEY` with your actual API key.

### Endpoints

#### 1. Encrypt string (GET)

Encrypts plain text passed in the query string and returns the ciphertext as a base64 string. Because the text and the key appear in the URL, prefer the POST version for anything sensitive.

**Method:** `GET`

**Endpoint:** `/api/Cryptor/encryptstring`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `plainText` | query | Plain text to encrypt. URL-encode it. | string | Yes | - | - |
| `secretKey` | query | Secret key used to encrypt. Keep it, you need the same key to decrypt. | string | Yes | - | - |
| `cryptAlgorithm` | query | Algorithm: `AES`, `DES`, `TripleDES`, `RC2` or `Rijndael`. | string | Yes | - | - |
| `cipherMode` | query | Cipher mode: `CBC`, `ECB` or `CFB`. | string | No | `CBC` | - |

**Example Request:**

```bash
curl -X GET "https://prod.api.market/api/v1/zsmartsoft/encryption-api/api/Cryptor/encryptstring?plainText=api.market%20round%20trip&secretKey=MySecretKey2026&cryptAlgorithm=AES&cipherMode=CBC" \
  -H "x-api-market-key: YOUR_API_KEY"
```

**Example Response (200 OK):**

```json
{
  "status": "Success",
  "result": "eX6KlHyoGtMCCOVZ7gRdHJMnk8FYvpgdck8aq/2YAgk="
}
```

#### 2. Encrypt string (POST)

Encrypts plain text sent in a JSON body and returns the ciphertext as a base64 string. This keeps the text and the key out of the URL.

**Method:** `POST`

**Endpoint:** `/api/Cryptor/encryptstring`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `plainText` | body | Plain text to encrypt. | string | Yes | - | - |
| `secretKey` | body | Secret key used to encrypt. | string | Yes | - | - |
| `cryptAlgorithm` | body | Algorithm: `AES`, `DES`, `TripleDES`, `RC2` or `Rijndael`. | string | Yes | - | - |
| `cipherMode` | body | Cipher mode: `CBC`, `ECB` or `CFB`. | string | No | `CBC` | - |

**Example Request:**

```bash
curl -X POST "https://prod.api.market/api/v1/zsmartsoft/encryption-api/api/Cryptor/encryptstring" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"plainText":"api.market round trip","secretKey":"MySecretKey2026","cryptAlgorithm":"TripleDES","cipherMode":"CBC"}'
```

**Example Response (200 OK):**

```json
{
  "status": "Success",
  "result": "nxZAxj131hFh7kKwL9sBvT6847iFLx/N"
}
```

#### 3. Encrypt file (multipart upload)

Encrypts a file uploaded as the multipart form field `plainfile` and returns the encrypted file as raw bytes (`application/octet-stream`). Save the response to a file.

**Method:** `POST`

**Endpoint:** `/api/Cryptor/encryptfileX`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `secretKey` | query | Secret key used to encrypt. | string | Yes | - | - |
| `cryptAlgorithm` | query | Algorithm: `AES`, `DES`, `TripleDES`, `RC2` or `Rijndael`. | string | Yes | - | - |
| `cipherMode` | query | Cipher mode: `CBC`, `ECB` or `CFB`. | string | No | `CBC` | - |
| `plainfile` | form | The file to encrypt. | file | Yes | - | - |

**Example Request:**

```bash
curl -X POST "https://prod.api.market/api/v1/zsmartsoft/encryption-api/api/Cryptor/encryptfileX?secretKey=MySecretKey2026&cryptAlgorithm=AES&cipherMode=CBC" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -F "plainfile=@invoice.txt" \
  -o invoice.txt.enc
```

**Example Response (200 OK):**

The response body is the encrypted file as binary data: in our test, a 55-byte text file encrypted with AES in CBC mode came back as 64 bytes.

#### 4. Encrypt file (raw body)

Encrypts the raw request body, sent as file bytes with `Content-Type: application/octet-stream`, and returns the encrypted bytes. Use it when you have the file in memory or want to stream it without building a multipart form.

**Method:** `POST`

**Endpoint:** `/api/Cryptor/encryptfile`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `secretKey` | query | Secret key used to encrypt. | string | Yes | - | - |
| `cryptAlgorithm` | query | Algorithm: `AES`, `DES`, `TripleDES`, `RC2` or `Rijndael`. | string | Yes | - | - |
| `cipherMode` | query | Cipher mode: `CBC`, `ECB` or `CFB`. | string | No | `CBC` | - |
| (request body) | body | The raw bytes of the file to encrypt, sent as `application/octet-stream`. | binary | Yes | - | - |

**Example Request:**

```bash
curl -X POST "https://prod.api.market/api/v1/zsmartsoft/encryption-api/api/Cryptor/encryptfile?secretKey=MySecretKey2026&cryptAlgorithm=AES&cipherMode=CBC" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/octet-stream" \
  --data-binary "@invoice.txt" \
  -o invoice.txt.enc
```

**Example Response (200 OK):**

The response body is the encrypted file as binary data: in our test, a 55-byte text file sent as the raw body came back as 64 encrypted bytes with AES in CBC mode.

#### 5. Decrypt string (GET)

Decrypts a base64 ciphertext passed in the query string and returns the original text. Use the same secret key, algorithm and cipher mode that encrypted it, and URL-encode the base64 value, because `+`, `/` and `=` have special meaning in URLs.

**Method:** `GET`

**Endpoint:** `/api/Cryptor/decryptstring`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `encryptedText` | query | Base64 ciphertext to decrypt, URL-encoded. | string | Yes | - | - |
| `secretKey` | query | The same secret key used to encrypt. | string | Yes | - | - |
| `cryptAlgorithm` | query | The same algorithm used to encrypt: `AES`, `DES`, `TripleDES`, `RC2` or `Rijndael`. | string | Yes | - | - |
| `cipherMode` | query | The same cipher mode used to encrypt: `CBC`, `ECB` or `CFB`. | string | No | `CBC` | - |

**Example Request:**

```bash
curl -X GET "https://prod.api.market/api/v1/zsmartsoft/encryption-api/api/Cryptor/decryptstring?encryptedText=eX6KlHyoGtMCCOVZ7gRdHJMnk8FYvpgdck8aq%2F2YAgk%3D&secretKey=MySecretKey2026&cryptAlgorithm=AES&cipherMode=CBC" \
  -H "x-api-market-key: YOUR_API_KEY"
```

**Example Response (200 OK):**

```json
{
  "status": "Success",
  "result": "api.market round trip"
}
```

**Example Failure Response (200 OK, wrong key):**

The same request with `secretKey=WrongKey` still returns HTTP `200`, with `status` set to `Failure`:

```json
{
  "status": "Failure",
  "result": "Exception: Padding is invalid and cannot be removed."
}
```

#### 6. Decrypt string (POST)

Decrypts a base64 ciphertext sent in a JSON body and returns the original text. Note that the body field is `encText`, not `encryptedText` as in the GET version.

**Method:** `POST`

**Endpoint:** `/api/Cryptor/decryptstring`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `encText` | body | Base64 ciphertext to decrypt. No URL-encoding needed. | string | Yes | - | - |
| `secretKey` | body | The same secret key used to encrypt. | string | Yes | - | - |
| `cryptAlgorithm` | body | The same algorithm used to encrypt: `AES`, `DES`, `TripleDES`, `RC2` or `Rijndael`. | string | Yes | - | - |
| `cipherMode` | body | The same cipher mode used to encrypt: `CBC`, `ECB` or `CFB`. | string | No | `CBC` | - |

**Example Request:**

```bash
curl -X POST "https://prod.api.market/api/v1/zsmartsoft/encryption-api/api/Cryptor/decryptstring" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"encText":"eX6KlHyoGtMCCOVZ7gRdHJMnk8FYvpgdck8aq/2YAgk=","secretKey":"MySecretKey2026","cryptAlgorithm":"AES","cipherMode":"CBC"}'
```

**Example Response (200 OK):**

```json
{
  "status": "Success",
  "result": "api.market round trip"
}
```

#### 7. Decrypt file (multipart upload)

Decrypts an encrypted file uploaded as the multipart form field `encfile` and returns the original file as raw bytes (`application/octet-stream`). Use the same secret key, algorithm and cipher mode that encrypted it.

**Method:** `POST`

**Endpoint:** `/api/Cryptor/decryptfileX`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `secretKey` | query | The same secret key used to encrypt. | string | Yes | - | - |
| `cryptAlgorithm` | query | The same algorithm used to encrypt: `AES`, `DES`, `TripleDES`, `RC2` or `Rijndael`. | string | Yes | - | - |
| `cipherMode` | query | The same cipher mode used to encrypt: `CBC`, `ECB` or `CFB`. | string | No | `CBC` | - |
| `encfile` | form | The encrypted file to decrypt. | file | Yes | - | - |

**Example Request:**

```bash
curl -X POST "https://prod.api.market/api/v1/zsmartsoft/encryption-api/api/Cryptor/decryptfileX?secretKey=MySecretKey2026&cryptAlgorithm=AES&cipherMode=CBC" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -F "encfile=@invoice.txt.enc" \
  -o invoice.txt
```

**Example Response (200 OK):**

The response body is the decrypted file as binary data: in our test, the 64-byte encrypted file decrypted back to the original 55-byte text file, identical byte for byte.

#### 8. Decrypt file (raw body)

Decrypts the raw request body, sent as encrypted bytes with `Content-Type: application/octet-stream`, and returns the original file bytes.

**Method:** `POST`

**Endpoint:** `/api/Cryptor/decryptfile`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `secretKey` | query | The same secret key used to encrypt. | string | Yes | - | - |
| `cryptAlgorithm` | query | The same algorithm used to encrypt: `AES`, `DES`, `TripleDES`, `RC2` or `Rijndael`. | string | Yes | - | - |
| `cipherMode` | query | The same cipher mode used to encrypt: `CBC`, `ECB` or `CFB`. | string | No | `CBC` | - |
| (request body) | body | The raw encrypted bytes to decrypt, sent as `application/octet-stream`. | binary | Yes | - | - |

**Example Request:**

```bash
curl -X POST "https://prod.api.market/api/v1/zsmartsoft/encryption-api/api/Cryptor/decryptfile?secretKey=MySecretKey2026&cryptAlgorithm=AES&cipherMode=CBC" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/octet-stream" \
  --data-binary "@invoice.txt.enc" \
  -o invoice.txt
```

**Example Response (200 OK):**

The response body is the decrypted file as binary data: in our test, 64 encrypted bytes decrypted back to the identical 55-byte original file.

## Status Codes

| Code | Status | Description |
|---|---|---|
| 200 | OK | The request was processed. For the text endpoints, always check the `status` field: `Success` means `result` holds the output, while `Failure` means the operation failed and `result` holds the error message, for example `Exception: Padding is invalid and cannot be removed.` when the key, algorithm or cipher mode does not match. File endpoints return the file bytes. |
| 400 | Bad Request | A required parameter is missing or invalid, for example no `secretKey`, an unknown `cryptAlgorithm` or `cipherMode`, a malformed JSON body, or no file in the request. |
| 401 | Unauthorized | The `x-api-market-key` value is invalid or expired. |
| 403 | Forbidden | Your subscription does not include this endpoint. |
| 404 | Not Found | The endpoint path does not exist. Check the path and its casing, for example `/api/Cryptor/encryptfileX`. |
| 429 | Too Many Requests | You went over your plan's requests-per-second limit, or you used all the calls in the Free plan. |
| 500 | Internal Server Error | Something failed while processing the request, for example a file that could not be decrypted. Check the key, algorithm and mode, then retry after a short delay. |

## Rate Limits

The Free plan allows 5 requests per second, the Pro plan 50 requests per second and the Mega plan 500 requests per second. Free includes 5 calls in total as a 7-day trial with a hard limit. Pro includes 30,000 calls and Mega 300,000 calls, and both allow extra calls beyond the quota at $0.001 per call instead of blocking you. Every call counts as one call whichever endpoint you use. Requests above the per-second limit, or after the Free plan's calls are used up, return `429 Too Many Requests`. Back off before retrying and honour any `Retry-After` header. In our tests each call took about 0.6 to 0.9 seconds for small text and files.

## FAQ

**Why did I get HTTP 200 when decryption failed?**

The text endpoints report errors inside the JSON body rather than with an HTTP error code. A failed call returns `200` with `"status": "Failure"` and an error message in `result`. For example, decrypting with the wrong key returned `Exception: Padding is invalid and cannot be removed.` Always check `status` before you use `result`.

**What do I need to decrypt something?**

The same `secretKey`, `cryptAlgorithm` and `cipherMode` that were used to encrypt it. If any of them differs, decryption fails or does not return the original data. The API has no key storage or key management endpoint, so keep your own record of which key, algorithm and mode you used for each item.

**Should I use GET or POST for text?**

Prefer POST. With GET, the text and the secret key are part of the URL, which tools and logs often record. With GET you must also URL-encode the base64 ciphertext, because `+`, `/` and `=` have special meaning in URLs (for example `/` becomes `%2F` and `=` becomes `%3D`). The POST body takes the base64 value as it is.

**What is the difference between `encryptfileX` and `encryptfile`?**

Both encrypt a file and return the encrypted bytes. `encryptfileX` takes the file as a multipart form field named `plainfile`, and `encryptfile` takes the raw file bytes as the request body with `Content-Type: application/octet-stream`. The decrypt pair works the same way: `decryptfileX` uses the form field `encfile`, and `decryptfile` takes raw bytes.

**Is my secret key sent to the service?**

Yes. The key is part of every request, because the service does the encryption. The API.market gateway uses HTTPS, so the key is encrypted in transit, but you should still keep keys secret, avoid putting them in URLs where possible, and never commit them to source code.

**Why is the encrypted file bigger than the original?**

The block ciphers pad the data before encrypting it. In our test, a 55-byte text file became 64 bytes after AES encryption in CBC mode, and decrypting it returned the identical 55 bytes.

**Which algorithm should I choose?**

All five options, `AES`, `DES`, `TripleDES`, `RC2` and `Rijndael`, are supported on every endpoint. If you are not matching an existing system, AES is the common choice for new work. Pick DES, TripleDES or RC2 when you need to read or produce data for a system that already uses them.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Encryption API to encrypt and decrypt text and files with AES, DES, TripleDES, RC2 or Rijndael. Returns base64 ciphertext or the encrypted file bytes.

Encryption API: AES, DES, TripleDES Encrypt and Decrypt