Encrypted Audio Transcriptions (RVENC)

curl --request POST \
  --url https://gateway.prem.io/rvenc/audio/transcriptions \
  --header 'Authorization: <api-key>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "encryptedInference": "<string>",
  "cipherText": "<string>",
  "nonce": "<string>",
  "encryptedFileName": "<string>",
  "fileNameNonce": "<string>",
  "encryptedFile": "<string>",
  "fileNonce": "<string>"
}
'

import requests

url = "https://gateway.prem.io/rvenc/audio/transcriptions"

payload = {
    "encryptedInference": "<string>",
    "cipherText": "<string>",
    "nonce": "<string>",
    "encryptedFileName": "<string>",
    "fileNameNonce": "<string>",
    "encryptedFile": "<string>",
    "fileNonce": "<string>"
}
headers = {
    "Authorization": "<api-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    encryptedInference: '<string>',
    cipherText: '<string>',
    nonce: '<string>',
    encryptedFileName: '<string>',
    fileNameNonce: '<string>',
    encryptedFile: '<string>',
    fileNonce: '<string>'
  })
};

fetch('https://gateway.prem.io/rvenc/audio/transcriptions', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://gateway.prem.io/rvenc/audio/transcriptions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'encryptedInference' => '<string>',
    'cipherText' => '<string>',
    'nonce' => '<string>',
    'encryptedFileName' => '<string>',
    'fileNameNonce' => '<string>',
    'encryptedFile' => '<string>',
    'fileNonce' => '<string>'
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: <api-key>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://gateway.prem.io/rvenc/audio/transcriptions"

	payload := strings.NewReader("{\n  \"encryptedInference\": \"<string>\",\n  \"cipherText\": \"<string>\",\n  \"nonce\": \"<string>\",\n  \"encryptedFileName\": \"<string>\",\n  \"fileNameNonce\": \"<string>\",\n  \"encryptedFile\": \"<string>\",\n  \"fileNonce\": \"<string>\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

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

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://gateway.prem.io/rvenc/audio/transcriptions")
  .header("Authorization", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"encryptedInference\": \"<string>\",\n  \"cipherText\": \"<string>\",\n  \"nonce\": \"<string>\",\n  \"encryptedFileName\": \"<string>\",\n  \"fileNameNonce\": \"<string>\",\n  \"encryptedFile\": \"<string>\",\n  \"fileNonce\": \"<string>\"\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://gateway.prem.io/rvenc/audio/transcriptions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"encryptedInference\": \"<string>\",\n  \"cipherText\": \"<string>\",\n  \"nonce\": \"<string>\",\n  \"encryptedFileName\": \"<string>\",\n  \"fileNameNonce\": \"<string>\",\n  \"encryptedFile\": \"<string>\",\n  \"fileNonce\": \"<string>\"\n}"

response = http.request(request)
puts response.read_body

{
  "status": 200,
  "data": {
    "id": "123"
  },
  "error": null,
  "log": null,
  "validator": null,
  "support_id": null,
  "message": "Resource created successfully",
  "env": "development"
}

{
  "error": "<string>",
  "message": null,
  "log": "<string>",
  "support_id": "3c90c3cc-0d44-4b50-8888-8dd25736052a",
  "data": {},
  "validator": {}
}

{
  "status": 401,
  "error": "<string>",
  "message": null,
  "log": "<string>",
  "support_id": "3c90c3cc-0d44-4b50-8888-8dd25736052a",
  "data": {},
  "validator": {}
}

{
  "status": 403,
  "error": "<string>",
  "message": null,
  "log": "<string>",
  "support_id": "3c90c3cc-0d44-4b50-8888-8dd25736052a",
  "data": {},
  "validator": {}
}

{
  "status": 123,
  "error": "<string>"
}

{
  "status": 123,
  "error": "<string>"
}

POST

rvenc

audio

transcriptions

Encrypted Audio Transcriptions (RVENC)

curl --request POST \
  --url https://gateway.prem.io/rvenc/audio/transcriptions \
  --header 'Authorization: <api-key>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "encryptedInference": "<string>",
  "cipherText": "<string>",
  "nonce": "<string>",
  "encryptedFileName": "<string>",
  "fileNameNonce": "<string>",
  "encryptedFile": "<string>",
  "fileNonce": "<string>"
}
'

import requests

url = "https://gateway.prem.io/rvenc/audio/transcriptions"

payload = {
    "encryptedInference": "<string>",
    "cipherText": "<string>",
    "nonce": "<string>",
    "encryptedFileName": "<string>",
    "fileNameNonce": "<string>",
    "encryptedFile": "<string>",
    "fileNonce": "<string>"
}
headers = {
    "Authorization": "<api-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    encryptedInference: '<string>',
    cipherText: '<string>',
    nonce: '<string>',
    encryptedFileName: '<string>',
    fileNameNonce: '<string>',
    encryptedFile: '<string>',
    fileNonce: '<string>'
  })
};

fetch('https://gateway.prem.io/rvenc/audio/transcriptions', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://gateway.prem.io/rvenc/audio/transcriptions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'encryptedInference' => '<string>',
    'cipherText' => '<string>',
    'nonce' => '<string>',
    'encryptedFileName' => '<string>',
    'fileNameNonce' => '<string>',
    'encryptedFile' => '<string>',
    'fileNonce' => '<string>'
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: <api-key>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://gateway.prem.io/rvenc/audio/transcriptions"

	payload := strings.NewReader("{\n  \"encryptedInference\": \"<string>\",\n  \"cipherText\": \"<string>\",\n  \"nonce\": \"<string>\",\n  \"encryptedFileName\": \"<string>\",\n  \"fileNameNonce\": \"<string>\",\n  \"encryptedFile\": \"<string>\",\n  \"fileNonce\": \"<string>\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

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

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://gateway.prem.io/rvenc/audio/transcriptions")
  .header("Authorization", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"encryptedInference\": \"<string>\",\n  \"cipherText\": \"<string>\",\n  \"nonce\": \"<string>\",\n  \"encryptedFileName\": \"<string>\",\n  \"fileNameNonce\": \"<string>\",\n  \"encryptedFile\": \"<string>\",\n  \"fileNonce\": \"<string>\"\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://gateway.prem.io/rvenc/audio/transcriptions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"encryptedInference\": \"<string>\",\n  \"cipherText\": \"<string>\",\n  \"nonce\": \"<string>\",\n  \"encryptedFileName\": \"<string>\",\n  \"fileNameNonce\": \"<string>\",\n  \"encryptedFile\": \"<string>\",\n  \"fileNonce\": \"<string>\"\n}"

response = http.request(request)
puts response.read_body

{
  "status": 200,
  "data": {
    "id": "123"
  },
  "error": null,
  "log": null,
  "validator": null,
  "support_id": null,
  "message": "Resource created successfully",
  "env": "development"
}

{
  "error": "<string>",
  "message": null,
  "log": "<string>",
  "support_id": "3c90c3cc-0d44-4b50-8888-8dd25736052a",
  "data": {},
  "validator": {}
}

{
  "status": 401,
  "error": "<string>",
  "message": null,
  "log": "<string>",
  "support_id": "3c90c3cc-0d44-4b50-8888-8dd25736052a",
  "data": {},
  "validator": {}
}

{
  "status": 403,
  "error": "<string>",
  "message": null,
  "log": "<string>",
  "support_id": "3c90c3cc-0d44-4b50-8888-8dd25736052a",
  "data": {},
  "validator": {}
}

{
  "status": 123,
  "error": "<string>"
}

{
  "status": 123,
  "error": "<string>"
}

TypeScript SDK

The SDK is available on GitHub: premAI-io/api-sdk-ts

Usage

Basic Setup

Create a client with auto-generated encryption keys:

import createRvencClient from "@premai/api-sdk";
import fs from "fs";

const client = await createRvencClient({
  apiKey: process.env.API_KEY,
  clientKEK: process.env.CLIENT_KEK
});

Pre-generate Keys

You can pre-generate encryption keys and reuse them:

import createRvencClient, { generateEncryptionKeys } from "@premai/api-sdk";

const encryptionKeys = await generateEncryptionKeys();

const client = await createRvencClient({
  apiKey: process.env.API_KEY,
  encryptionKeys,
  requestTimeoutMs: 60000,  // optional
  maxBufferSize: 20 * 1024 * 1024, // optional
});

Basic Transcription

const transcription = await client.audio.transcriptions.create({
  file: fs.createReadStream('./audio.wav'),
  model: 'openai/whisper-large-v3',
});

console.log(transcription.text);

Transcription with Options

const transcription = await client.audio.transcriptions.create({
  file: fs.createReadStream('./audio.mp3'),
  model: 'openai/whisper-large-v3',
  language: 'en',
  prompt: 'This is a discussion about artificial intelligence.',
  response_format: 'verbose_json',
  temperature: 0,
  timestamp_granularities: ['word', 'segment'],
});

Configuration

Option	Default	Description
`file`	required	Audio file (ReadStream, Buffer, Blob, etc.)
`model`	required	Model ID (e.g., `'openai/whisper-large-v3'`)
`language`	auto-detect	ISO-639-1 language code (e.g., `'en'`, `'de'`, `'fr'`)
`prompt`	optional	Text prompt to guide the model
`response_format`	`'json'`	Format: `'json'`, `'text'`, or `'verbose_json'`
`temperature`	`0`	Sampling temperature (0-1)
`timestamp_granularities`	optional	Array of `'word'` and/or `'segment'` for timestamps

Note: openai/whisper-large-v3 model supports non-streaming only.

OpenAI-Compatible API Server

Run as a standalone server with automatic DEK store management per API key:

bunx -p @premai/api-sdk confidential-proxy
# Server runs on http://127.0.0.1:8000

Use with any OpenAI-compatible client:

curl http://127.0.0.1:8000/v1/audio/transcriptions \
  -H "Authorization: Bearer your-api-key" \
  -F "file=@audio.mp3" \
  -F "model=openai/whisper-large-v3"

Or use the SDK directly in Node.js:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.API_KEY,
  baseURL: "http://127.0.0.1:8000/v1",
});

const transcription = await client.audio.transcriptions.create({
  file: fs.createReadStream('./audio.mp3'),
  model: 'openai/whisper-large-v3',
});

console.log(transcription.text);

The server caches clients in memory per API key for better performance.

Authorizations

Authorization

string

header

required

Send your access token as header Authorization: Bearer {accessToken}

Authorization

string

header

required

Your API key that starts with sk_live or sk_test. You can create yours at go.prem.io/api-keys.

Body

application/json

Request body for rvenc (raw volatile encrypted) audio transcription. Contains an encrypted payload with cryptographic materials needed for decryption.

encryptedInference

string

required

Encrypted JSON string containing all audio transcription parameters. When decrypted, this string must match the structure shown in the expandable _decryptedInference property below (reference only - do not send this property).

cipherText

string

required

Cipher text for shared secret generation (ECDH key exchange)

nonce

string

required

Nonce used for encrypting the inference payload

encryptedFileName

string

required

The encrypted audio file name. The file name is encrypted using XChaCha20-Poly1305 with the shared secret and fileNameNonce.

fileNameNonce

string

required

Nonce used for encrypting the encrypted audio file name

encryptedFile

string

required

The encrypted audio file data. The audio content is encrypted using XChaCha20-Poly1305 with the shared secret and fileNonce.

fileNonce

string

required

Nonce used for encrypting the encrypted audio file

Response

Encrypted audio transcription response. The response contains the encrypted transcription result which must be decrypted using the shared secret derived from the request's cipherText, along with the response nonce.

status

enum<integer>

required

Status code of the response

Available options:

200,

201,

202

data

object

required

Encrypted audio transcription response. Contains the encrypted transcription result that must be decrypted using the shared secret derived from the request's cipherText.

Show child attributes

Example:

{
  "encryptedResponse": "a1b2c3d4e5f67890abcdef1234567890abcdef123456789012345678901234567890abcdef...",
  "nonce": "f6e5d4c3b2a19876543210fedcba9876"
}

message

string | null

required

Message of the response, human readable

Example:

"Resource created successfully"

env

enum<string>

required

API environment

Available options:

development,

production

error

string | null

Error message of the response, human readable

Example:

"Invalid email address"

log

Useful informaiton, not always present, to debug the response

Examples:

{ "request_id": "req_1234567890" }

"Some pertinent log message"

validator

Validator response object, each key is the field name and value is the error message

Example:

{
  "email": "Invalid email address",
  "password": "Password is required"
}

support_id

string<uuid> | null

Support ID linked to the response, used to identify it when talking with our team

Example:

"support_uuidv7-something-else"

Encrypted Chat Completions (RVENC)Encrypted Audio Translations (RVENC)

GET STARTED

BILLING

API REFERENCE

Encrypted Audio Transcriptions (RVENC)

TypeScript SDK

Usage

Basic Setup

Pre-generate Keys

Basic Transcription

Transcription with Options

Configuration

OpenAI-Compatible API Server

Authorizations

Body

Response

​TypeScript SDK

​Usage

​Basic Setup

​Pre-generate Keys

​Basic Transcription

​Transcription with Options

​Configuration

​OpenAI-Compatible API Server

Authorizations

Body

Response

TypeScript SDK

Usage

Basic Setup

Pre-generate Keys

Basic Transcription

Transcription with Options

Configuration

OpenAI-Compatible API Server