Beyond REST: Connecting to gRPC and GraphQL APIs with a Single Platform

In the world of software development, APIs are the bedrock of modern applications. For years, REST has been the undisputed king, a familiar and reliable way to connect services. But the kingdom is expanding. High-performance microservices are adopting gRPC, and data-intensive frontends are leveraging the power of GraphQL.

While this diversity offers specialized tools for the job, it creates a new headache for developers: integration fragmentation. Your team now has to master three different API paradigms, juggle multiple client libraries, and manage distinct authentication flows. This complexity slows down development, bloats your codebase, and makes maintenance a nightmare.

What if you could interact with any API—REST, GraphQL, or gRPC—through one consistent, unified interface? What if you could abstract away the underlying protocol and treat every external system as a simple, callable service?

Welcome to the future of system connectivity with integrations.do.

The Challenge: A Tale of Three APIs

To appreciate the solution, let's quickly recap the problem. A modern application might need to:

Fetch customer data from Salesforce (REST): The classic, resource-based approach. It's well-understood but can lead to over-fetching unnecessary data or requiring multiple calls to get related information.
Query product details for a web app (GraphQL): Perfect for front-end clients that need to request a specific shape of data in a single round trip, avoiding the pitfalls of REST.
Communicate with an internal billing microservice (gRPC): A high-performance RPC framework ideal for low-latency, high-throughput communication between internal services.

Managing these three requires your application to handle different request formats, error patterns, and client setups. The cognitive overhead is significant.

The Solution: A True "API for APIs"

integrations.do is built on a simple yet powerful premise: your application code shouldn't have to care about the architecture of the systems it connects to. We provide a universal translation layer, an API for all your other APIs.

You define the integration logic once on our platform—how to authenticate, where to send requests, and how to map data—and we expose it as a simple, programmatic service. We call this Business-as-Code.

Whether you're fetching a customer record from a REST API or creating an invoice via a gRPC call, the code in your application looks remarkably similar and clean.

import { integrations } from '@do/sdk';

// 1. Fetch a customer from a REST API (e.g., Salesforce)
const customer = await integrations.salesforce.run('getCustomerByEmail', {
  email: 'jane.doe@acme.com'
});

// 2. Query a public GraphQL API (e.g., GitHub)
const issues = await integrations.github.run('getRepoIssues', {
  owner: 'do-inc',
  repo: 'integrations-sdk'
});

// 3. Call an internal gRPC service (e.g., Billing)
const invoice = await integrations.billing_service.run('createInvoice', {
  customerId: customer.id,
  amount: 9900
});

// All the complexity of REST endpoints, GraphQL queries, and 
// gRPC stubs is handled automatically by the .do platform.

Notice the consistency. Your developer no longer needs to be an expert in three different protocols. They only need to know how to call a function.

How It Works: Connect Any API, Supported or Not

This unifying power isn't limited to our pre-built connectors. The integrations.do platform is designed to connect to any API, including your own private or legacy systems. The process is straightforward:

Define the System: In your integrations.do workspace, you start by defining a new integration. Here, you specify the protocol: REST, GraphQL, or gRPC.
Secure Your Credentials: Connect your accounts once. Whether it's OAuth 2.0, an API Key, or a JWT Bearer, you store your credentials in our secure vault. Our platform handles the entire authentication lifecycle, including complex token refreshes, so your application code stays clean and secure.
Configure Actions: This is where the magic happens. You map simple action names (like getCustomerByEmail or createInvoice) to the underlying API calls.
- For REST, you point to an endpoint and HTTP method.
- For GraphQL, you provide the query or mutation.
- For gRPC, you specify the service and RPC method.
Transform Data (Optional): You can apply powerful transformations to standardize the API response before it ever reaches your application, ensuring you always work with clean, predictable data structures.

From Integration Chaos to Workflow Automation

This approach fundamentally changes how you build software. It moves beyond simple event-based automation (like in no-code tools) and gives developers programmatic, on-demand control over their entire tech stack.

Radical Simplicity: A single SDK and mental model for every integration reduces cognitive load and accelerates development.
Enhanced Maintainability: Need to update an API endpoint or authentication method? Change it once in the integrations.do dashboard, and every application using it is instantly updated. No code redeployment is necessary.
Seamless Workflow Automation: By turning every system into a callable service, you can easily orchestrate complex workflows directly in your code, creating powerful Services-as-Software that drive your business.

The era of juggling different API clients is over. It's time to unify your system connectivity and empower your developers to build faster and more reliably.