Opening RSC Flow Docs

Connection lost

RSC Flow 1

RSC+ developer platform

Automate every live moment.

RSC Flow turns RSC+ events into secure, predictable webhook requests. This complete reference covers syntax, typed values, event payloads, delivery, testing, troubleshooting, and production safeguards.

Start building Open Studio

01 · Quickstart

Your first integration

Create a coded integration in Studio, paste this program, choose an event, add an HTTPS endpoint, then validate and save.

Event relay

RSCFLOW 1
METHOD POST
HEADER X-Team = "RSC+"
REQUIRE data.title
SET event = event
SET title = data.title
SET payload = data

Every program begins with RSCFLOW 1. Statements run from top to bottom. The final body is serialized as JSON and signed when a signing secret is configured.

02 · Language

Seven statements, clear behavior

RSC Flow is line oriented. Blank lines and lines beginning with # are ignored. Values can be variable paths, JSON strings, objects, arrays, numbers, booleans, or null.

Statement	Behavior
RSCFLOW 1	Declares language version 1. It must be the first real statement.
METHOD POST	Sets POST, PUT, or PATCH. POST is the default.
HEADER Name = value	Adds a safe custom request header.
REQUIRE data.title	Stops delivery when a required value is missing.
SET output.path = value	Writes a typed value into the JSON body.
PUSH output.list = value	Appends a value to an output array.
BODY value	Replaces the complete request body.

03 · Data

Built-in variables

Use variable paths directly to preserve their type. Use {{path}} inside a quoted string or JSON value to interpolate text.

Variable	Meaning
event	The event name, such as video.published.
createdAt	The event timestamp in ISO 8601 format.
source	The source identifier, currently rsc-plus.
data	The complete event payload as an object.
data.title	A nested field from the event payload.
integration.id	The connected integration identifier.
integration.name	The integration name from Studio.

04 · Events

Connect to the platform

Choose one event in Studio or select all events. Test deliveries use sample data so you can verify the request before it reaches production.

broadcast.created

Delivered when this RSC+ platform action completes.

broadcast.ended

Delivered when this RSC+ platform action completes.

video.published

Delivered when this RSC+ platform action completes.

short.published

Delivered when this RSC+ platform action completes.

short.ad.impression

Delivered when this RSC+ platform action completes.

announcement.published

Delivered when this RSC+ platform action completes.

ad.forced

Delivered when this RSC+ platform action completes.

effect.triggered

Delivered when this RSC+ platform action completes.

platform.maintenance

Delivered when this RSC+ platform action completes.

05 · Recipes

Common patterns

These programs are ready to paste into Integration Studio. Change the endpoint and wording to match your workflow.

Discord message

RSCFLOW 1
METHOD POST
REQUIRE data.title
BODY {"content":"New on RSC+: {{data.title}}"}

Nested fields and arrays

RSCFLOW 1
METHOD PATCH
SET event_name = event
SET story.title = data.title
PUSH tags = "sports"
PUSH tags = data.slug

Legacy JSON recipe

{"method":"POST","headers":{"X-Team":"RSC+"},"body":{"event":"{{event}}","payload":"{{data}}"}}

06 / Syntax

Values and JSON types

RSC Flow values are typed. Direct variable paths preserve their original type. Interpolation inserts text into a string or JSON structure.

Syntax	Result
"Championship"	String literal
1284	Number literal
true or false	Boolean literal
null	Null literal
{"status":"ready"}	JSON object literal
["live","sports"]	JSON array literal
data.title	Variable path that preserves its type
"Published: {{data.title}}"	Interpolated text
{"title":"{{data.title}}"}	Interpolated JSON

Version 1 grammar

program   = version, statement*
version   = "RSCFLOW 1"
statement = method | header | require | set | push | body
method    = "METHOD " ("POST" | "PUT" | "PATCH")
header    = "HEADER " name " = " value
require   = "REQUIRE " variable_path
set       = "SET " output_path " = " value
push      = "PUSH " output_path " = " value
body      = "BODY " value
value     = variable_path | JSON value | interpolated JSON

Use SET payload = data to forward the complete typed data object. Using "{{data}}" turns the value into text.

07 / Runtime

Execution model

Statements run from top to bottom and build one outgoing request. The order is deterministic, so the same event and program produce the same request.

1. Read context

The event envelope supplies event, createdAt, source, data, and integration values.

2. Check requirements

REQUIRE stops the delivery when an essential path is missing, null, or empty.

3. Build headers

HEADER evaluates safe custom metadata without replacing protected transport headers.

4. Build the body

SET writes fields, PUSH appends arrays, and BODY replaces the complete result.

Order and nesting

RSCFLOW 1
METHOD PATCH
SET notification.kind = event
SET story.title = data.title
SET story.is_live = false
PUSH story.tags = "rsc-plus"
PUSH story.tags = data.slug
SET metrics.views = 1284

BODY replaces the complete outgoing body. Put it last when it is the final result, or place it before later SET and PUSH statements only when it produces an object.

08 / Data contracts

Event envelope and payloads

Every trigger uses the same outer envelope. Event-specific fields live inside data. Integrations should ignore unknown fields so new platform data remains backward compatible.

Representative event

{
  "id": "evt_01JABC123",
  "event": "video.published",
  "createdAt": "2026-08-12T18:42:00.000Z",
  "source": "rsc-plus",
  "data": {
    "id": "video_782",
    "title": "Championship Replay",
    "slug": "championship-replay",
    "status": "published",
    "views": 1284
  }
}

Event	Common data
broadcast.created	Broadcast ID, title, status, and Cloudflare Live input details.
broadcast.ended	Broadcast ID, title, status, and recording details.
video.published	Video ID, title, slug, status, and views.
short.published	Short ID, title, slug, creator, and category.
short.ad.impression	Campaign ID, title, placement, and impression data.
announcement.published	Announcement ID, title, message, and severity.
ad.forced	Campaign ID, title, duration, and placement.
effect.triggered	Effect ID, message, subtitle, and duration.
platform.maintenance	Access state, title, message, and automatic reopen time.

09 / HTTP

Delivery and response behavior

RSC+ sends compact JSON to the configured public HTTPS endpoint. A healthy receiver returns any 2xx status quickly, then performs slower work in its own queue.

Representative request

POST /rsc/events HTTP/1.1
Content-Type: application/json
X-RSC-Event: video.published
X-RSC-Delivery: evt_01JABC123
X-RSC-Signature-256: sha256=6d4c...
X-RSC-Automation: studio

Content type

Bodies use application/json with UTF-8 encoding.

Event header

X-RSC-Event identifies the trigger before the body is parsed.

Delivery identity

Use the delivery ID for logs and duplicate protection.

Successful response

Return a 2xx status when the event has been accepted.

Complete body replacement

RSCFLOW 1
METHOD PUT
REQUIRE data.id
BODY {"type":"{{event}}","resource":{"id":"{{data.id}}","title":"{{data.title}}"},"sent_at":"{{createdAt}}"}

10 / Workflow

Validate, test, then activate

Validation compiles the program with sample data and previews the request. Testing sends a real request to the saved endpoint.

Validate syntax

Resolve every line-specific error before saving.

Inspect the preview

Check the method, headers, body nesting, and JSON types.

Send a test

Confirm the destination logs contain the expected request.

Monitor production

Review the last delivery state after the first real event.

Receivers should be idempotent. Processing the same logical event again should not create duplicate posts, graphics, or records.

11 / Troubleshooting

Error reference

Validation errors identify program problems before delivery. HTTP errors mean the program compiled but the destination rejected or failed the request.

Message	What to check
Begin the script with RSCFLOW 1	The required version line is missing.
Unsupported RSC Flow version	Only version 1 is currently accepted.
Unknown RSC Flow statement	Check the keyword, spacing, output path, and equals sign.
Expected a value	A HEADER, SET, PUSH, or BODY statement has no value.
Invalid JSON value	A string, object, or array contains invalid JSON syntax.
Required variable is missing	REQUIRE could not find its value in the current event.
PUSH target is not an array	A previous SET created a non-array value at the same path.
Unsafe output path	The path contains a protected JavaScript object property.
Endpoint must use HTTPS	Only public HTTPS destinations can be saved.
Delivery returned HTTP error	The endpoint responded without a successful 2xx status.

12 / Production

Language and delivery limits

RSC Flow is intentionally small. It cannot execute arbitrary code, access storage, read secrets, or make additional network requests.

Limit	Current value
Language version	RSC Flow 1
Program length	12,000 characters
Executable statements	120 per program
Custom headers	Up to 20 safe headers
Header value	500 characters after interpolation
HTTP methods	POST, PUT, and PATCH
Destinations	Public HTTPS endpoints only

13 / Reference

Frequently asked questions

Quick answers for common integration design decisions.

Webhook or RSC Flow?

Use a standard webhook for the complete envelope. Use RSC Flow for a custom body or headers.

Can I use Discord or Slack?

Yes. Use an incoming webhook URL and one of the recipes in this guide.

Can one program call two endpoints?

No. Create a separate integration for each destination.

Can I add Authorization?

No. Use the HMAC signature or a safe destination-specific custom header.

What if a variable is missing?

It resolves to an empty value. Use REQUIRE to stop delivery instead.

Do comments count as statements?

No. Blank lines and full comment lines are ignored.

Can I loop over arrays?

Version 1 has no loops. PUSH creates arrays and direct paths can forward existing arrays.

Will version 1 change?

Its behavior is fixed. Future syntax will require a new version declaration.

14 / Security

Safe by design

RSC Flow does not use eval, dynamic functions, filesystem access, or arbitrary network calls. It only builds the request sent to the HTTPS endpoint configured in Studio.

Signed delivery

Set a secret to receive X-RSC-Signature-256 with an HMAC SHA-256 signature.

Protected headers

Host, authorization, cookies, connection, content length, event, and signature headers cannot be overwritten.

Bounded programs

Source is limited to 12,000 characters and 120 executable statements.

Public HTTPS only

Integration endpoints must use HTTPS and cannot target local or private network addresses.

For signature verification, compute HMAC SHA-256 over the raw request body and compare it with the value after sha256= in the signature header.