API Documentation. Precision Built In.
The Perception X2 API documentation provides complete reference material for every protocol, endpoint, authentication flow, and data model available on the platform. Built for developers who need precision, not guesswork.
500+ Endpoints · REST / WebSocket / gRPC / Webhooks · <120ms Response Time
Comprehensive Reference for Every Protocol
Perception X2 is an autonomous perception amplification platform developed by CryptoMize. The API documentation serves as the definitive reference for every interaction with the platform.
This documentation covers four connection protocols — REST for standard operations, WebSocket for real-time streaming, gRPC for high-performance binary communication, and Webhooks for event-driven notifications. Each protocol section includes endpoint specifications, request and response schemas, authentication requirements, and working code examples in Python, JavaScript/TypeScript, and Go.
Whether you are building a sentiment analysis pipeline, configuring crisis detection webhooks, deploying narratives across multiple platforms, or constructing real-time analytics dashboards, this documentation provides the technical depth to move from concept to production without ambiguity. Every endpoint is documented with its HTTP method, path, parameters, request body schema, response schema, error codes, rate limit impact, and authentication requirements.
The Perception X2 API exposes 500+ endpoints across eight functional domains, each designed for specific integration patterns. This page maps those domains, explains the protocols that carry them, and provides the reference material needed to build robust integrations.
Reference Material Developers Actually Use
Most API documentation tells you what an endpoint does. Perception X2 documentation shows you how to build with it — production-ready patterns, error handling, and deployment strategies.
Complete Endpoint Catalog
Every REST, WebSocket, gRPC, and Webhook endpoint documented with method, path, parameters, request/response schemas, and error codes. No undocumented behavior, no assumed knowledge.
Multi-Protocol Reference
Side-by-side documentation for REST, WebSocket, gRPC, and Webhooks. Each protocol section explains when to use it, how to connect, and what data formats to expect.
Authentication Flows
Step-by-step documentation for OAuth 2.0 client credentials, authorization code grants, API key authentication, and mTLS. Token lifecycle management, scope definitions, and security best practices covered in depth.
Working Code Examples
Copy-paste-ready code in Python, JavaScript/TypeScript, and Go for every major API operation. Examples include error handling, retry logic, and production-ready patterns — not just the happy path.
Rate Limit and Quota Reference
Tier-based rate limit tables, header documentation, 429 response handling strategies, and optimization techniques. Every endpoint's rate limit impact is documented.
Error Catalog
Structured error response format, complete error code table, resolution guidance for every error condition, and retry strategy recommendations.
Versioning and Migration
Semantic versioning policy, deprecation timelines, breaking change notification process, and migration guides for every major version transition. The API maintains a 2-year deprecation window.
Data Model Specifications
JSON and Protocol Buffer schema definitions for every request and response object. Field types, validation rules, required versus optional fields, and enum values are documented for all data models.
Four Protocols, One Comprehensive Reference
REST for standard operations. WebSocket for real-time streaming. gRPC for high-throughput binary communication. Webhooks for event-driven notifications. All documented with production-ready patterns and working code samples.
REST API
Standard CRUD operations, queries, and batch processing. JSON payloads with consistent response schemas. <120ms response time. 80-120ms average latency across 500+ endpoints.
WebSocket Streams
Real-time event streaming with sub-200ms delivery. Channel subscriptions, filters, and event replay. Persistent bidirectional connections for live dashboards and monitoring.
gRPC Services
High-throughput binary communication with Protocol Buffers. Bidirectional streaming. 30-80ms average latency. Persistent multiplexed connections for performance-critical integrations.
Webhook Events
Event-driven notifications with HMAC-SHA256 signatures. Configurable retry with exponential backoff. At-least-once delivery. Event payload includes full context and delivery identifiers.
From Zero to First API Call in Five Steps
Obtain API Credentials
Navigate to the Perception X2 Developer Portal and create a project. You will receive a client_id and client_secret for OAuth 2.0 authentication. Store these securely — the client secret is not retrievable after creation.
Install an SDK
Choose your language and install the official SDK: pip install perception-sdk (Python), npm install @cryptomize/perception-sdk (JavaScript), or go get github.com/CryptoMize/perception-sdk-go (Go).
Authenticate
Exchange your credentials for an access token. Token is obtained automatically on first API call when using an SDK. Manual token exchange available via POST /oauth/token.
Make Your First API Call
Query real-time sentiment data for a specific narrative. The SDK abstracts protocol negotiation, rate limiting, and error recovery.
Verify the Response
A successful response returns a structured JSON object with sentiment scores, confidence levels, and emotional dimension analysis. Compare against documented schema.
API Reference Capabilities
Complete Endpoint Catalog
Every REST, WebSocket, gRPC, and Webhook endpoint documented with method, path, parameters, request/response schemas, and error codes.
OAuth 2.0 Authentication
Client credentials, authorization code grants, and mTLS. Scoped permissions, automatic token refresh, and audit logging built in.
Working Code Examples
Python, JavaScript/TypeScript, and Go code samples for every major operation. Production patterns with error handling and retry logic.
Rate Limit Documentation
Tier-based rate limit tables, header reference, 429 response handling, and optimization strategies. Every endpoint's rate limit impact documented.
Error Code Reference
Structured error response format, complete error code table, resolution guidance, and retry strategy recommendations.
Data Model Schemas
JSON and Protocol Buffer schema definitions for every request and response object. Field types, validation rules, and enum values documented.
What Developers Build With the API
Sentiment Monitoring Dashboard
Build a real-time dashboard that displays sentiment scores across multiple platforms. Use WebSocket streaming for live updates and REST batch endpoints for historical trend data. Integration time: 2-4 hours with the Python SDK.
Automated Crisis Response System
Configure webhooks to detect crisis events and trigger automated response workflows. When crisis events arrive at your endpoint, execute predefined playbooks — activate counter-narratives, notify stakeholders, and begin monitoring escalation patterns.
Multi-Platform Content Deployment Pipeline
Integrate the Perception X2 deployment API into your content management workflow. Deploy narratives to 50+ platforms through a single API call, track deployment status in real time, and receive webhook notifications on completion or failure.
Competitive Intelligence Aggregation
Use the Intelligence domain endpoints to aggregate competitive data across platforms. Schedule periodic batch queries, store results in your analytics infrastructure, and generate comparative reports through the Analytics domain.
Embedded Perception API
Embed sentiment analysis capabilities into your own customer-facing products. Use the Sentiment domain API to provide real-time text analysis, emotional dimension scoring, and platform-specific sentiment breakdowns as a feature of your application.
Why Developers Choose This Documentation
Zero Ambiguity
Every endpoint documented with method, path, parameters, request/response schemas, and error codes. No guesswork required during integration.
Production-Ready Patterns
Code examples include error handling, retry logic, and pagination — not just the happy path. Patterns that ship to production.
Versioned Alongside the API
Documentation is versioned with the API itself. Developers working with a specific version see reference material that matches exactly.
Multi-Language Coverage
Working code in Python, JavaScript/TypeScript, and Go. Every example in every language — no translation work required.
Complete Schemas
JSON and Protocol Buffer schema definitions for every request and response. Field types, validation rules, and enum values are documented for all data models.
Operational Excellence
Rate limit headers, error codes, retry strategies, and webhook event catalogs — operational concerns documented as thoroughly as functional concerns.
What Makes the Perception X2 API Reference Different
Most API documentation tells you what an endpoint does. Perception X2 documentation shows you how to build with it — production-ready patterns, error handling, and deployment strategies.
500+ Documented Endpoints
Every REST, WebSocket, gRPC, and Webhook endpoint documented with method, path, parameters, schemas, and error codes.
Production-Tested Code
Code examples include error handling, retry logic, and pagination. Not just the happy path — patterns that ship to production.
Four Protocols, One Schema
REST, WebSocket, gRPC, and Webhooks share unified data models. Migrate between protocols without changing business logic.
99.9999% Uptime SLA
Tier-based rate limits, automatic retry, and circuit breaker patterns documented. Operational concerns covered as thoroughly as functional concerns.
Versioned Reference
Documentation is versioned alongside the API. Developers working with a specific version see reference material that matches exactly.
Enterprise Security
OAuth 2.0, mTLS, scope-based authorization, and audit logging. Security documentation meets enterprise compliance requirements.
Built for Engineers Building Production Systems
Backend Engineers
Building server-side integrations, automation pipelines, and data processing systems that consume Perception X2 APIs.
Frontend Developers
Constructing dashboards, monitoring interfaces, and real-time visualizations powered by WebSocket streams and REST queries.
Platform Engineers
Integrating Perception X2 into existing technology stacks — CRM systems, marketing platforms, analytics infrastructure.
Data Engineers
Building batch processing pipelines, analytics warehouses, and intelligence aggregation systems using gRPC streaming.
DevOps Teams
Configuring webhook receivers, building CI/CD integrations, and monitoring production deployments with event-driven automation.
Security Teams
Implementing OAuth 2.0 flows, mTLS certificate management, and scope-based access controls for enterprise-grade security.
The Standard for Perception Intelligence APIs
15+ Years of API Excellence
Every endpoint refined through thousands of real-world deployments across the world's most demanding environments.
300+ Elite Client Integrations
Trusted by governments, global enterprises, and institutions across multiple continents. Each engagement contributes to API refinement.
Zero Security Incidents
Your most sensitive API data protected by military-grade security. Zero incidents in 15+ years of operations.
Verified Performance
<120ms average response time, 99.9999% uptime, 50,000+ concurrent connections. These are verified operational metrics.
Multi-Protocol Support
REST, WebSocket, gRPC, and Webhooks from a unified API surface. Choose the protocol that matches your integration requirements.
Enterprise Authentication
OAuth 2.0 with scoped permissions, mTLS for high-security deployments, automatic token refresh, and comprehensive audit logging.
API Documentation — Common Developer Questions
What protocols does the Perception X2 API support?
How do I authenticate API requests?
What are the rate limits for the API?
Is there a sandbox environment for testing?
How does API versioning work?
What happens when an API request fails?
How do I handle real-time sentiment data?
Can I migrate from REST to gRPC without rewriting my integration?
How do webhooks differ from WebSocket streams?
Is the API compliant with SOC 2 and ISO 27001?
API Documentation — What Developers Ask
How do I get started with the Perception X2 API?
What is the difference between REST and gRPC APIs?
How can I get an API key?
Does the API support batch operations?
What happens to my integration when APIs are deprecated?
Begin Integrating Perception X2
Request API access to start with the sandbox environment, explore the full endpoint catalog, and build your integration with confidence. The developer support team is available for architecture guidance and enterprise onboarding.
Our developer support team is available for architecture guidance, integration planning, and enterprise onboarding.
All integrations begin with the sandbox environment — test against realistic data without affecting production deployments.