Developer API & Proposed Streaming Designs

These states distinguish public pages and code from operator-managed access and proposed integrations. A published interface does not imply validated accuracy or guaranteed availability.

Download the OpenAPI 3.1 JSON, Postman collection, or Bruno collection ZIP. Import the OpenAPI file directly into Bruno or extract the ZIP and open its collection folder. Choose a local WAV file inside the client before sending. These artifacts describe the implemented complete-recording route; they contain no live credentials.

Server signing is optional. A signed vendor receipt is a bare Ed25519 attestation, not a C2PA credential. The Proof Lab shows local receipt and source-hash checks; independent issuer trust and audio-byte matching are separate checks. This API uses JavaScript; the separate local WebAssembly sandbox below is not its runtime. Live streaming, SIP/PBX transport and C2PA packaging are not implemented by this API.

For existing C2PA WAV manifests, the local verification ZIP includes a Python wrapper, generated-tone development fixtures, public test certificates and file hashes. It requires official c2patool 0.28.1 installed separately, plus an independently obtained signer leaf certificate. Linux x86-64 tests distinguish valid claim integrity from signer trust and reject tampered, mismatched, unsigned and malformed inputs. Primary validation disables remote-manifest and OCSP fetching; certificate extraction reads the exact local binary manifest. This is not OS network isolation and revocation is not freshly checked offline. It does not authenticate speakers, validate detector accuracy or establish C2PA certification.

Selecting a file here does not send it. Clicking Send file for verification uploads the selected WAV to the Cloudflare-hosted API. The server processes audio in memory and can store its SHA-256 digest and result metadata in D1. This differs from the local browser demo. Read Privacy & Data Handling: Server API before sending. Do not upload sensitive recordings to this public prototype. Results and confidence are uncalibrated; an unsigned response is normal when signing is unavailable.

No file sent.

This sandbox downloads a compiled acoustic scorer and runs it in a dedicated browser Worker. Your recording and result stay on this device; no API key or server upload is involved. WAV decoding uses the shared JavaScript decoder. The main demo, pilot API, MCP tools and SDK continue to use the JavaScript scorer. This compiled port does not establish new detection accuracy or a speed improvement. Its decision and confidence fields are uncalibrated, and its verdict does not authenticate a speaker.

Download engine hashes, source link and compilation flags. The module uses at most 128 MiB of WebAssembly linear memory; browser decoding and page memory are additional.

No local analysis yet. Analysis stops after 30 seconds of wall time; cancellation terminates the Worker.

Inspects uncompressed PCM WAV (8, 16, or 24 bit), float32 WAV, or raw 16 kHz PCM16 audio. Decode MP3, AAC, FLAC, OGG, or WebM before calling this endpoint. Suitable for batch processing, voicemail verification, and post-call auditing.

The file-verification route is POST /api/v1/verify. It accepts limited unauthenticated requests at a lower rate limit; a valid operator-issued bearer key enables the authenticated rate limit. The examples below assume a key has been issued.

For URL input, the pilot operator must configure exact trusted HTTPS source hosts in AUDIO_URL_ALLOWED_HOSTS. Every redirect target is checked against that list. An unset list denies URL fetching; direct audio uploads remain available.

curl -X POST https://noiseorvoice.com/api/v1/verify \
  -H "Authorization: Bearer $NOISEORVOICE_API_KEY" \
  -F "audio=@synthetic_edgetts_aria.wav" \
  -F "sensitivity=0.75" \
  -F "extract_telemetry=true"

Selected response fields for the repository sample synthetic_edgetts_aria.wav (SHA-256 a2182a4daa125dd49a068db016716788663be138b27712bfb5caad8959f0cea3) using the local JavaScript engine at threshold 0.75. This is a local example, not a live endpoint measurement:

{
  "status": "success",
  "verdict": "SYNTHETIC_DETECTED",
  "confidence_score": 0.999,
  "decision_score": 0.999,
  "score_semantics": "uncalibrated_detection_score",
  "score_calibrated": false,
  "confidence_calibrated": false,
  "scoring_engine": "noiseorvoice-js-dsp/2.4-SPECTRA",
  "threshold_evaluated": 0.75,
  "duration_seconds": 3.5,
  "is_synthetic": true,
  "is_authentic": false,
  "is_conclusive": true,
  "telemetry": {
    "vocoder_phase_incoherence": 0.517,
    "glottal_jitter_variance": 2.4347,
    "rolloff_95_hz": 2219
  },
  "flags": [
    "LOW_ABSOLUTE_LPC_RESIDUAL_SKEW",
    "ELEVATED_COMB_NOTCH_SCORE",
    "ELEVATED_PHASE_CURVATURE_DISPERSION",
    "HIGH_FRACTIONAL_LAG1_VARIABILITY"
  ],
  "attestation": null,
  "signing_status": "unavailable"
}

The example shows selected telemetry keys; actual telemetry includes additional fields. decision_score is the uncalibrated detector output. confidence_score is an uncalibrated display transform, not a probability that the verdict is correct. Thresholds are operating points on this engine's score scale.

This proposed contract illustrates live telephony (SIP/RTP) and WebRTC integration. No WebSocket service is deployed at stream.noiseorvoice.com. The current SDK streaming helpers make separate HTTP verification calls for chunks; they do not maintain a server-side session or guarantee per-frame latency.

// 1. Client sends session initialization:
> {"action":"init","sample_rate":16000,"channels":1,"format":"pcm16","sensitivity":0.65}
< {"status":"ready","session_id":"<server-generated>"}

// 2. Client sends decoded PCM chunks; framing policy remains to be designed:
> [Binary 640 bytes PCM frame 101]
< {"event":"chunk_received","frame_seq":101}

// 3. A future service would buffer enough speech for a scored utterance:
< {"event":"verification_verdict","utterance_id":"<server-generated>","verdict":"<rule-output>","decision_score":"<uncalibrated>"}

From a repository checkout supplied by the operator, run python3 -m pip install -e ./sdk/python. No public PyPI release is established. This SDK method submits a WAV file to the pilot REST endpoint:

from noiseorvoice import VoiceVerifier

verifier = VoiceVerifier()
result = verifier.verify_file("sample.wav", sensitivity=0.50)
print(result.verdict, result.decision_score)

From a repository checkout supplied by the operator, run npm --prefix sdk/typescript ci, npm --prefix sdk/typescript run build, then npm install ./sdk/typescript in the consuming project. No public npm release is established. This SDK method verifies a file through the REST endpoint:

import { VoiceVerifier } from '@noiseorvoice/sdk';

const verifier = new VoiceVerifier();
const result = await verifier.verifyFile('sample.wav', { sensitivity: 0.50 });
console.log(result.verdict, result.decision_score);

Conceptual Protocol Buffers sketch for a future telecom gateway. It is not a published schema or implemented service; message definitions and error behavior would need to be completed before use:

syntax = "proto3";
package noiseorvoice.v1;

service AudioClassificationService {
  rpc StreamVerifyAudio (stream AudioPacket) returns (stream StreamTelemetryResponse);
}

message AudioPacket {
  string session_id = 1;
  uint64 sequence_number = 2;
  bytes pcm_payload = 3;
  uint32 sample_rate = 4;
}

message StreamTelemetryResponse {
  uint64 sequence_number = 1;
  float frame_anomaly_score = 2;
  string stream_status = 3; // "MONITORING", "ANOMALY_SPIKE", "VOICED_LATCHED"
  float phase_dispersion = 4;
  optional string latched_verdict = 5; // e.g. "SYNTHETIC_DETECTED" or "AUTHENTIC_HUMAN"
  optional float latched_decision_score = 6; // uncalibrated
}

These sketches show possible telephony adapters. No Twilio, Asterisk, FreeSWITCH, Genesys, SIP proxy, or WebSocket connector is deployed by this repository. A production adapter would need codec decoding, windowed analysis, latency measurement, authentication, and caller consent appropriate to its deployment. The current selected In-the-Wild benchmark does not support an automatic fraud-lockout policy.

<Response>
  <Start>
    <Stream url="wss://your-connector.example.invalid/twilio" />
  </Start>
  <Say>Connecting you to telephone banking.</Say>
  <Dial>+18005550199</Dial>
</Response>

; Asterisk Dialplan: extensions.conf
[inbound-banking]
exten => _X.,1,Answer()
same => n,AudioSocket(4b9a1d32-84f9-41bc-92a0-1284920bc91a,adapter.example.invalid:9092)
same => n,Dial(PJSIP/agent-pool,30)

When a private signing key is configured, the REST response includes an attestation record with an Ed25519 signature and an audio SHA-256 digest. The SDK verifies the signature, the audio hash when audio is supplied, and a caller-configured trusted key pin. A valid signature protects the recorded detector claim; independent evaluation is needed to assess the classification.

An unsigned response reports attestation: null and signing_status: "unavailable". SDK verification reports issuer_trusted only when the verified key matches a pin obtained independently of the receipt.

No completed independent assurance report is provided for this service. No external audit in progress is established by the available evidence.

Status as of 2026-10-05. This is a repository and operator self-report, not third-party assurance. Check the published status record and request current evidence from the operator before sensitive use.

Audio and metadata handling in repository code

The verification function processes submitted audio in memory and does not write that audio to the contribution database. Audit rows store an audio digest, verdict, key prefix, and timing metadata; the separate rate-limit table records client IPs. Deployment storage, logs, retention, and deletion procedures need operational review.

Voluntary research contributions are separate: with consent, a microphone recording and limited metrics are stored in the contribution database. The contribution receipt ID authorizes deletion through POST /api/contribution-delete. Keep that ID private. No automatic deletion period is established in this repository.

When integrating Noise or Voice into security-critical pathways (such as banking wire authorization, call center voice biometrics, or live executive communication), engineering teams must account for the machine learning cat-and-mouse dynamic.

Adversarial Telemetry Flags

The current Cloudflare DSP endpoint may emit these heuristic flags. They describe measured feature conditions, not a proven attack mechanism:

• INSUFFICIENT_PITCH_PERIODICITY: Too little periodic structure for a conclusive voiced-speech analysis.
• ELEVATED_PHASE_CURVATURE_DISPERSION: A phase-curvature estimate crossed an internal heuristic threshold.
• HIGH_FRACTIONAL_LAG1_VARIABILITY: A lag-1 correlation variability estimate crossed an internal heuristic threshold.

Run the included tests and analysis scripts from a checkout with their dependencies installed. Results depend on the code version, corpus, and environment:

# 1. Run Python unit and integration tests
python3 -m pytest

# 2. Run automated continuous regression test gate across baseline ledger
python3 scripts/regression_gate.py

# 3. Run acoustic feature discovery script
python3 scripts/discover-acoustic-signatures.py

# 4. Run Python benchmark engine across all 29 verification corpus samples
python3 -m engine.benchmark

# 5. Recompute the 168-trial sweep if the local corpus audio is present
python3 -m engine.benchmark --eval-corpus

# 6. Classify one audio sample; signed receipt requires a configured key
python3 -m engine.cli verify site/audio/samples/human_real_biden_speech.wav

# 7. Verify all 29 audio samples with client-side JavaScript DSP engine
node scripts/test-js-dsp.mjs

# 8. Run full Playwright E2E UI & verification test suite
node scripts/test-e2e.mjs