Captures in real time
Contributors record directly into the platform using WebRTC. Audio streams live to storage. Ten-second chunks merge into clean files server-side.
No laptop uploads, no third-party clients, no manual handoffs.
The platform behind the [standard].
Real-time capture. Automated scoring. Full chain of custody. Every file ships with its receipts.
Most AI data vendors will tell you they have a process.
Ask to see the pipeline, the code, the actual file path a recording takes from a contributor’s microphone to a dataset card, and the conversation shifts.
We built UsergyAI as a platform first. Which means when you buy from us, what you’re buying is a system, not a service agreement.
Four things, built in.
Scores every file automatically
Language detection, voice activity, speaker diarization, signal quality. Every recording passes a multi-model QA sweep before a human ever reviews it.
Files that fail flag before they hit the queue.
Tracks provenance at the source
Identity, consent, timestamp, and project scope attach to each file at the moment of capture. Not added later. Not assembled at delivery.
Provenance is built into the file, not glued to the outside of it.
Delivers datasets with receipts
Every shipment includes a dataset card documenting contributor profiles, consent terms, licensing scope, and the full QC trail. Auditable on arrival.
From microphone to dataset.
A recording moves through six stages. Every stage produces an artifact that belongs to the file, not a separate spreadsheet.
Identity
Contributor signs in. Platform verifies skill match, language, and consent scope for the current project.
Capture
Browser records via WebRTC. Audio streams to storage in 10-second chunks over a signed upload path.
Merge
A worker assembles the chunks server-side, writes the final WAV, hashes it, and timestamps the boundary.
Score
QA worker runs the file through language, VAD, diarization, and signal-quality models. Scores attach to the file record.
Review
Admin queue surfaces files for human review. Approve, reject, or flag for rework. Every decision is logged.
Deliver
Approved files assemble into a dataset card with provenance attached. Card ships with contributor profiles, consent, and QC trail.
Real components. Not slideware.
- Frontend
- Next.js, deployed on edge
- Real-time
- LiveKit over WebRTC
- Storage
- Azure Blob, region-pinned
- Database
- Azure PostgreSQL, encrypted at rest
- Language ID
- Whisper-tiny
- Voice activity
- Silero VAD
- Diarization
- pyannote 3.1
- Merge worker
- Polling every 30 seconds
- QA worker
- Polling every 60 seconds
Named because the components determine what the output is made of. If we won’t tell you what the pipeline runs on, you shouldn’t trust the files that come out of it.
Here is what ships with every file.
- file_id
- sha256 hash, universally unique
- contributor_id
- verified identity, anonymized for delivery
- consent_version
- signed agreement at time of capture
- rights_commercial
- true / false per file
- rights_derivative
- true / false per file
- rights_redistribute
- true / false per file
- capture_timestamp
- microsecond accuracy
- qa_scores
- language, diarization, signal, switch
- review_log
- every human decision, with actor and time
- project_scope
- what this file was collected for
If an auditor asks how you acquired this data, the answer is already in the file.
Direct access for integration teams.
- Dataset download
- REST API or signed S3-compatible URLs
- Sample access
- HuggingFace, Datarade, or direct link
- Custom collection
- Scoped by project ID with webhook callbacks
- Consent framework
- Versioned, machine-readable, documented
Not a full developer portal yet. Reach out and we’ll scope what your integration needs.
The ones we get most.
How is this different from a data annotation company?
Annotation companies label data that was collected elsewhere. We run the collection. Every file on our platform is captured through our own pipeline, from a contributor who signed our consent framework, on a project we scoped with the buyer. Labeling is a stage, not the product.
Can we commission data for a modality you don't list?
Yes. The platform handles audio, image, video, text, multimodal, and sensor capture. If your project needs a format we haven’t built for yet, we’ll scope the tooling as part of the project.
Do you use any of our data to train your own models?
No. Buyer data is delivered and then purged from our processing systems according to your contract. We don’t train on client data. We don’t resell custom collections. The dataset is yours.
How do we know the contributor actually consented?
Every file carries its consent version and signature timestamp in the file record. The signed consent document is retrievable by contributor ID. You can audit any file down to the form it was signed on.
What's the minimum project size?
We scope projects from a few dozen hours of audio up to enterprise-scale multi-month collections. The platform is built for repeated use, not one-off spec work. If the scope is a single small pilot, we’ll say so.
How fast can a project start?
A typical custom project scopes within 48 hours of the first conversation. Contributor sourcing and pipeline setup usually takes 3 to 7 days. First files begin arriving in the second week of most projects.
Where are contributors located?
Across 20+ countries. Our network is globally distributed with coverage in major and underrepresented languages, dialects, and accent profiles. Project matching prioritises native speakers for every locale.
What happens if a file fails QA?
It doesn’t ship. The platform holds rejected files in a review queue. If a whole project fails quality thresholds, we re-scope, re-capture, or refund. The dataset ships clean or it doesn’t ship at all.