The Rereflect Public API: Build on Your Feedback Data

Your feedback data, programmatically accessible

A dashboard is great until you need to do something the dashboard does not do. You want to pipe feedback into your data warehouse. You want to ingest messages from a channel Rereflect does not natively connect to. You want to surface a customer's health score inside your own internal admin tool. You want to trigger a workflow the moment a piece of feedback is flagged urgent.

For all of that, Rereflect exposes a Public REST API. Because Rereflect is self-hosted and open source, this is not a gated upsell — the API runs on your own instance, against your own data, and you can build whatever you need on top of it.

The API is organized around the same concepts you see in the product: feedback, customers, health, churn signals, and analytics for reading, plus an ingestion path for writing feedback in, and webhooks for getting events pushed out.

Authentication with API keys

The Public API authenticates with API keys rather than the user-session tokens the dashboard uses. An API key represents a programmatic client — a script, a service, an integration — rather than a logged-in person, which makes keys easy to rotate and revoke without touching anyone's account.

Keys are scoped, so a client only gets the access it needs. The two core scopes map to the two things you do with the API:

• Read scope — query feedback, customers, health scores, churn signals, and analytics. Ideal for dashboards, reporting jobs, and read-only integrations.
• Ingest scope — push new feedback into Rereflect. Ideal for connectors that pull from a source Rereflect does not natively support and forward it in.

Following least privilege, give each integration only the scope it actually requires: a reporting pipeline should hold a read-only key, while an inbound connector needs ingest. If a key leaks, revoke it and issue a new one — no user passwords or sessions are involved.

Reading your data

The read endpoints expose the analyzed data Rereflect produces, so you can take insights out of the dashboard and put them wherever your team works. Everything that drives the UI is reachable programmatically:

• Feedback — list and retrieve feedback items along with their analysis: sentiment, categories, and urgency flags.
• Customers — pull customer records to join Rereflect's view of a customer with your own systems.
• Health — read customer health scores to surface risk where your team already looks.
• Churn — access churn signals and risk indicators for proactive retention work.
• Analytics — retrieve aggregate metrics and trends for reporting and warehousing.

Because these endpoints return structured JSON, they slot cleanly into the tools you already use — a scheduled job that loads feedback into your warehouse, an internal admin panel that shows a customer's health inline, or a weekly report that pulls analytics on a cron.

Ingesting feedback programmatically

Reading is only half the story. The ingestion endpoint lets you push feedback into Rereflect from anywhere, which means you are never limited to the sources Rereflect connects to out of the box.

The pattern is straightforward: a client holding an ingest-scoped key sends feedback to the API, and Rereflect runs it through the same analysis pipeline as feedback from any other source — sentiment, categorization, urgency, the works. The feedback then appears in the dashboard and in the read API exactly like everything else.

• Custom connectors — pull from a channel Rereflect does not natively integrate (a niche support tool, an internal forum, a community platform) and forward each message in.
• Bulk backfill — load historical feedback from a prior system so your trends and analytics reflect your full history, not just data since you adopted Rereflect.
• Embedded capture — wire a feedback widget in your own product directly to the ingestion endpoint, so in-app feedback flows straight into analysis.

Whatever the source, once feedback is ingested it is a first-class citizen: analyzed, categorized, scored, and queryable through the same read API.

Webhooks for real-time events

Polling the read API on a schedule works, but for time-sensitive reactions you want to be notified the moment something happens rather than discovering it on your next poll. That is what webhooks are for.

With webhooks, Rereflect pushes events to a URL you control as they occur. Instead of asking "has anything urgent come in?" every few minutes, your endpoint is called the instant it does — letting you react in real time.

Typical uses include alerting and automation: post urgent feedback to a Slack channel as it arrives, open a ticket in your issue tracker when a churn-risk signal fires, or kick off an internal workflow when a customer's health crosses a threshold. Because the event comes to you, the latency between something happening in Rereflect and your team acting on it shrinks to near zero.

OpenAPI docs and getting started

The whole API is described with OpenAPI, so you do not have to guess at endpoints, parameters, or response shapes. The interactive docs let you browse every endpoint, see request and response schemas, and try calls directly. The same OpenAPI definition also feeds client-generation tooling, so you can generate a typed client in your language of choice instead of writing HTTP plumbing by hand.

Because Rereflect is open source and self-hosted, the API and its docs run on your own instance against your own data — no external dependency, no rate-limit negotiations with a vendor, no data leaving your control. Clone Rereflect, create an API key with the scope you need, open the OpenAPI docs, and start building on top of your feedback data.