01 / Glue code
Every API gets its own script
Each partner or SaaS API ends up with a custom service that polls tables, formats payloads and retries failed calls. Every one of them is code your team owns and credentials it has to protect.
Gluesync Module · REST API integration
Courier
The HTTP client built into Gluesync for REST API integration. Call any REST API, stream every captured change to an HTTP endpoint, publish REST endpoints over your tables, and invoke stored procedures in your databases, all from the Control Plane.
Courier / Outbound endpoints / Fernhill CRM
Upsert customerFernhill CRM
PUT
/customers/{customerId}| Binding | Type | In | Sample values |
|---|---|---|---|
customerId* | string | path | C-20418 |
notify | boolean | query | false |
email* | string | body | r.okafor@larchmont.example |
loyaltyTier | string | body | gold |
lifetimeValue | number | body | 18420.75 |
marketingOptIn | boolean | body | true |
- 01 Design and test any REST call
- 02 Stream every change to an HTTP endpoint
- 03 Serve REST endpoints and stored procedures
Why Courier
Every API your data touches, in one place
02 / Two tools
Tested in one tool, run in another
Engineers build the request in a desktop API client, then rewrite it by hand for production. The tested request and the running request drift apart, and API secrets end up in personal workspaces.
03 / The platform outcome
One definition, every direction
Courier keeps endpoint definitions in Core Hub, next to your pipelines. Call an API on demand, let every captured change call it, publish your tables as REST endpoints, or invoke a stored procedure, all governed like the rest of the Control Plane.
How it works
Define once, test, then connect
- 01
Define
A collection per API
Create a collection with a base URL and authentication. Add endpoints with a path template, headers and typed bindings that fill {name} placeholders.
- 02
Test
See the exact request, then send it
The request updates as you edit. Click “Send test request” to see the status code, response headers, body and duration. Every run lands in “Saved test history”.
- 03
Connect
Stream it or serve it
Use “Map to pipeline” so every captured change calls the endpoint. Or publish inbound endpoints over a table and hand the consuming team an access token.
Capabilities
Outbound, streaming and inbound: one HTTP layer for your data
Courier sits in the Conductor menu next to Query Studio, and every collection and endpoint is stored in Core Hub. The HTTP Target agent delivers pipeline rows and serves inbound endpoints from your own network.
Outbound endpoints
A REST client in the Control Plane
Collections, typed bindings and one-click tests
Model each external API once. A collection holds the base URL and authentication, and each endpoint adds a path template, headers and bindings. Secrets are encrypted at rest in Core Hub, masked in every API response and redacted in test history.
- Collections per API: base URL plus None, Basic, Bearer or API-key auth (header or query string)
- GET, POST, PUT, PATCH, DELETE, HEAD and OPTIONS, with JSON or form-urlencoded bodies
- Typed string, number and boolean bindings in path, query, header or body, with defaults and required flags
- “Send test request” on saved or unsaved definitions, with status, headers, response body, duration and “Saved test history”
- Export endpoint definitions as a JSON file and load them back with “Import endpoints file”
Courier / Outbound endpoints / Fernhill CRM / Upsert customer
Upsert customerFernhill CRMApplied in crm-sync
PUT
/customers/{customerId}| Binding | Type | In | Req. | Default |
|---|---|---|---|---|
customerId | string | path | — | |
notify | boolean | query | false | |
email | string | body | — | |
loyaltyTier | string | body | standard | |
lifetimeValue | number | body | 0 | |
marketingOptIn | boolean | body | false |
Pipeline delivery
Every change becomes an HTTP call
The HTTP Target turns a Courier endpoint into a pipeline target
Map a Courier endpoint to a pipeline and the HTTP Target delivers to it like any other target. Each insert, update and delete captured from the source becomes an HTTP call built from the same definition you tested.
- Inserts, updates and deletes from any source agent are each sent to the endpoint you mapped, with the operation in the payload
- “Map to pipeline”: the collection is the target schema, the endpoint is the target table, and source columns map to bindings
- Binary values sent as Base64, arrays as JSON arrays, decimals in plain notation
- A non-2xx response or transport failure puts the entity in error, and Core Hub replays from the checkpoint, so no change is lost
- Endpoint edits reach running HTTP Targets live, with no restart
Pipelines / crm-sync / public.customers / Mapping
crm-sync
Entitypublic.customers · Running
pg-salesPostgreSQLHTTP Targetyour network| Source column | Type | Binding | In | |
|---|---|---|---|---|
id | varchar(12) | {customerId} | path | |
email | varchar(120) | {email} | body | |
tier | varchar(16) | {loyaltyTier} | body | |
ltv | numeric(12,2) | {lifetimeValue} | body | |
opt_in | boolean | {marketingOptIn} | body |
Inserts1,284
Updates9,617
Deletes42
Errors0
Calls leave from your network
The HTTP Target runs where you deploy it, so outbound calls start inside your own network. Delivery metrics appear in the Control Plane like those of any other target.
Inbound endpoints
REST endpoints over your tables
Publish, secure and try generated endpoints and stored procedures without writing a service
Publish generated REST endpoints at /api-inbound/{basePath}/{path}, each mapped to a table on an agent Gluesync already manages. SQL is always parameterized and runs through the same execution path as Query Studio. Core Hub and the HTTP Target both serve the endpoints, close to the data, with “Copy curl command” and “Try it” next to every one.
- List with filters and paging, read by key, create, update and delete on a table Gluesync already manages
- Per-column controls: alias, insertable, updatable, filterable
- Personal API Tokens with the “Inbound endpoints” scope, optionally restricted to specific agents, with one-time reveal and expiry
- Inbound writes land in the source database, so CDC picks them up and your pipelines carry them onward
- Invoke stored procedures in your databases from Courier
Courier / Inbound endpoints / Order lookup
| Name | Scope | Agents | Expires |
|---|---|---|---|
| Support portal | Inbound endpoints | pg-sales | 2027-01-31 |
| Finance reports | Inbound endpoints | pg-sales | 2026-12-31 |
/api-inbound/orders-api/orders?status=OPEN&_limit=50&_offset=0curl -s "https://corehub.northbay.example/api-inbound/orders-api/orders?status=OPEN&_limit=50&_offset=0" \ -H "Authorization: Bearer gsp_••••••••"
| orderId | customerId | status | total |
|---|---|---|---|
100482 | C-20418 | OPEN | 1249.00 |
100479 | C-20391 | OPEN | 318.60 |
100471 | C-20107 | OPEN | 87.15 |
FAQ
Frequently asked questions
What is Courier in Gluesync?
Courier is the HTTP client built into Gluesync. It does four things from the Control Plane: it calls remote REST APIs you define and test, it streams every captured database change to an HTTP endpoint through a pipeline, it publishes REST endpoints over the tables Gluesync already manages, and it invokes stored procedures in your databases. Every definition is stored in Core Hub.
How do database changes reach a REST API?
Through the HTTP Target, a Gluesync pipeline target. Use “Map to pipeline” to pick a Courier collection as the target schema and an endpoint as the target table, then bind source columns to the endpoint's bindings. Every insert, update and delete captured from the source becomes an HTTP call to that endpoint, with the operation in the payload.
What happens when an endpoint returns an error?
A non-2xx response or a transport failure puts the entity in error, and Core Hub replays from the checkpoint, so no change is lost. Delivery metrics and entity status appear in the Control Plane like those of any other target.
Which authentication methods does Courier support for remote APIs?
Each collection uses None, Basic, Bearer or API-key authentication, with the key sent in a header or the query string. Secrets are encrypted at rest in Core Hub, masked in every API response and redacted in “Saved test history”.
How are inbound endpoints secured?
Callers authenticate with a Personal API Token as a Bearer token. The token needs the “Inbound endpoints” scope and can be restricted to specific agents. You create tokens in the “Access tokens” panel, see each one once, and set an expiry. SQL is always parameterized, identifiers are validated, and per-column controls set each column's alias and whether it is insertable, updatable or filterable.
Can Courier invoke stored procedures?
Yes. Courier invokes stored procedures in the databases Gluesync already manages, from the Control Plane and with the same Core Hub governance as every other Courier call. Business logic that already lives in your database stays there, and Courier calls it.
Which databases can inbound endpoints serve?
Any SQL-capable agent that Query Studio can query. Inbound endpoints run through the same execution path as Query Studio, and writes land in the source database, where CDC picks them up for your pipelines.
Explore the platform
Continue exploring Gluesync
Courier connects Gluesync pipelines to the APIs around them. Explore the rest of the platform.
Gluesync
Real-time CDC replication: the change stream that drives every Courier delivery.
Explore Gluesync →Integrations
63+ databases, streams and files that can feed an HTTP endpoint through Courier.
Explore Integrations →
Query Studio
The SQL workbench whose execution path serves Courier inbound endpoints.
Explore Query Studio →
Schedules and events
Chronos schedules, webhooks and Core Hub events to automate the rest of the platform.
Explore Schedules and events →Resources
Guides, roadmap and support
Documentation
Technical guides, API reference, deployment tutorials.
Read documentation ↗
Public Roadmap
What we're building next. Submit feature requests.
View roadmap ↗
Support
Access technical support and operational assistance.
Get support →
Service Status
Real-time platform availability and incident history.
Check status ↗Call it. Stream it. Serve it.
Request a free trial or talk with the MOLO17 team about connecting your pipelines to the REST APIs around them.