Participate in grid programs
Enable your devices for demand response, virtual power plants, load shifting, and other grid programs across utilities (cooperatives, municipal utilities, investor-owned utilities), CCAs, and ISO/RTO-driven programs.
OEM & TPDO partners
Integrate with Texture
One open, standards-based integration that connects your fleet to every utility, CCA, and program operator running on Texture.
Who we mean by OEM and TPDO
The integration program is open to both device manufacturers and any third-party that exercises operational control over customer-sited devices.
- OEM
Original equipment manufacturer
Companies that build energy hardware like batteries, inverters, EV chargers, thermostats, and other DERs, and expose cloud APIs for those devices.
- TPDO
Third-party demand orchestrator
Any third-party entity that enrolls, aggregates, orchestrates, dispatches, or otherwise exercises operational control over distributed energy resources or customer-sited devices, and provides a cloud-based interface (APIs or equivalent data services) for accessing telemetry, control signals, or program participation data — regardless of whether they manufacture the devices or operate them on behalf of a utility, market operator, or end customer.
What integration with Texture enables
Connect your devices to grid programs and unlock new value for your customers.
Unified telemetry
Provide standardized telemetry across all device types with a consistent data model for batteries, inverters, EV chargers, thermostats, and more.
Cloud-to-cloud control
Enable safe, deterministic control of your fleet through cloud APIs without firmware changes or hardware modifications.
Monetization opportunities
Unlock new revenue streams for your customers by participating in grid services and energy programs.
No hardware changes
Integrate through your existing cloud infrastructure. Texture connects via your APIs — no device firmware updates required.
Energy integrations today vs integrating with Texture
The legacy model of bespoke, opaque integrations slows down innovation and keeps the ecosystem small. Texture offers an open, reusable alternative.
Legacy model
- Bespoke MSAs and one-off deals for each utility, CCA, DERMS provider, and sometimes each program.
- Integration fees just to access APIs.
- API docs hidden behind NDAs and static PDFs.
- No reusable integration model; every integration is a snowflake.
Texture's open model
- Public docs and spec — no NDA required to understand how to integrate.
- No fee just to integrate with Texture; the goal is to get your fleet into programs.
- One canonical model, many programs — implement once, reuse across utilities, CCAs, and DERMS/VPP operators running on Texture.
- You can talk about your integration openly with customers and partners.
- OEMs and TPDOs keep control over their cloud APIs and safety logic; Texture orchestrates through your endpoints.
Cloud-to-cloud integration
Integrations happen through your existing cloud APIs, not hardware changes. Texture uses a unified, open model for telemetry, control, identity, and device lifecycle management. This model is shared across all Texture customers, so the same integration can be reused across multiple utilities, CCAs, and programs.
What your cloud needs to expose
The integration model leans on four primitives. Each one is described in detail in the Technical Requirements spec.
Authentication
Support OAuth2, API tokens, or signed requests for secure API access.
Stable identifiers
Provide consistent device IDs that persist across sessions and reconnections.
Real-time telemetry
Push or expose telemetry with sub-15-minute freshness for grid operations.
Deterministic control
Expose control endpoints with predictable, documented behavior and error handling.
Core documents
Engineering, legal, and security teams each get the right starting point for the parts of the integration they own.
Technical requirements
Defines telemetry schema, control model, authentication, rate limits, reliability expectations, eventing, and testing requirements. For engineering teams.
OEM & TPDO integration terms
Defines legal and operational responsibilities, cloud-control safety boundaries, data rights, liability, and uptime expectations. For legal, business development, and compliance teams.
Trust center
Security, privacy, and compliance information for Texture, including our controls, policies, and audit status. For security, compliance, and IT teams.
Integration path
From spec review to live on the platform. Most OEMs and TPDOs complete the path in weeks, not quarters.
- 01
Review the requirements
Confirm your cloud platform supports authentication (OAuth2, tokens, or signed requests), telemetry ingestion, stable device identifiers, control endpoints, and defined SLAs.
- 02
Execute the integration terms
Signing the Integration Terms establishes responsibilities around safe API behavior, device control boundaries, data rights, and operational expectations.
- 03
Workspace provisioning
Texture sets up a dedicated OEM Integration Workspace for telemetry ingest, device onboarding, identity management, and validation testing.
- 04
Certification testing
Validate telemetry shapes, control behavior, error codes, rate limits, and reliability requirements. Most OEMs complete certification quickly.
- 05
Go live
Once certified, your devices can be supported across Texture utility and CCA customers with no additional technical integration work. Individual utilities and CCAs decide which OEMs to include in their programs, but the underlying integration is ready to use.
Why OEMs and TPDOs integrate with Texture
The fastest, most efficient path to grid program participation and fleet monetization, using a single open integration model. One integration replaces the old pattern of bespoke agreements and custom builds for each new program.
One integration, many programs
A single Texture integration enables participation across all utility and CCA programs on the platform — no per-customer integration work. This replaces the old pattern of bespoke, one-off integrations and MSAs for each new program.
Unified DER model
Texture's standardized model means no bespoke customer-by-customer integrations. Your devices work consistently everywhere.
Utility-grade orchestration
Real-time data plane and dispatch-ready infrastructure built for grid-scale operations and reliability requirements.
OEM control preserved
You retain full control over your firmware, safety logic, and device behavior. Texture issues dispatch requests through your existing cloud API endpoints, and your platform enforces the safety envelope.
Fastest path to monetization
Get your deployed fleet earning revenue from grid services with the shortest time-to-market of any integration path.
Public docs, no integration fee
Our integration docs and requirements are public, and we don't charge a fee just to integrate with Texture.
Common questions
The short answers; the spec has the long ones.
Do we need to change our firmware?
No. Texture integrates cloud-to-cloud. You expose safe control endpoints and telemetry from your existing cloud platform.
What if our telemetry isn't real-time?
Texture can work with different cadences, but grid programs typically require sub-15-minute freshness. The Technical Requirements document spells out what's needed.
Can we start with telemetry only?
Yes. Many partners start by exposing telemetry and then add control endpoints once they're ready.
Do we have to be a Texture customer to integrate?
No. The Integration Terms govern the integration itself. Commercial use of the broader Texture platform is a separate agreement.
Ready to get your fleet into utility programs?
Send the integrations team a note and we will get you started with the spec, the workspace, and a path to certification.