The server
| Setting | Value |
|---|---|
| URL | https://api.screenrig.ai/mcp |
| Transport | Streamable HTTP, stateless. Every request is one POST. |
| Protocol | MCP 2026-07-28, sent as the MCP-Protocol-Version header. Clients that start with initialize negotiate 2025-11-25, 2025-06-18 or 2025-03-26. |
| Authentication | OAuth 2.0: Authorization: Bearer <access token> on every request |
| Responses | JSON, private to the project, never cached |
The server keeps no sessions. It refuses GET, DELETE, Mcp-Session-Id and cookies. Each request authenticates on its own, so a disconnected app stops working on its next call. Requests are limited to 4 MiB.
The MCP server covers the project's tools, from creating a project and uploading media to playlists, access and reports. The official plugin adds the steps that run on your machine, such as converting media and packing applications, which stay in the bundled CLI.
Connect with OAuth
MCP clients find the sign-in on their own. A request without a token answers 401 with WWW-Authenticate: Bearer resource_metadata="https://api.screenrig.ai/.well-known/oauth-protected-resource/mcp", and that document names the authorization server, https://api.screenrig.ai. Its metadata is at https://api.screenrig.ai/.well-known/oauth-authorization-server.
- Add the server URL to your client. The client opens the screenRIG consent page in your browser.
- Sign in to the dashboard if needed. The page shows the app's name and domain as the app declares them, whether screenRIG registered it, and where your browser returns.
- Choose the project, Read only, Propose or Manage, and the capabilities. If the app asked for the
identityscope, the page also offers identity access, off until you turn it on. Then choose Connect app and confirm with your passkey. - Your browser returns to the app, which now has its own session. It renews that session itself; each access token lasts 10 minutes.
Connect only an app you are setting up yourself, right now. Clients identify themselves with a Client ID Metadata Document (CIMD), so there is no registration step. Authorization uses PKCE with S256, exact redirect URIs, and a single-use code that lasts 60 seconds.
The app appears under Connected apps on the dashboard's Access page. Disconnect there ends it within seconds; reconnect it to choose a different project or access level. See Authentication for the sessions behind it.
The CLI and MCP host keep separate sessions. Do not copy the CLI’s saved token into the MCP configuration, paste credentials into a conversation, or pass them to an embedded card. The host handles its OAuth tokens and refresh.
The official plugin requests access:manage, screens, content, playlists and reports; the user approves access during sign-in. A fresh screenshot requires Propose or Manage access and the screens capability. An existing read-only connection needs renewed consent before requesting a capture.
The plugin's edition in the Claude directory has no CLI, so it also requests identity and project.
MCP Apps hosts can render interactive screen, media and playlist cards through the authenticated connection. The card uses the host’s MCP Apps bridge; it contains no credential and does not call the API directly. Hosts without MCP Apps rendering can still consume tool text and structured data.
Read only, Propose and Manage
Connected apps default to Read only. A Read only app lists only read tools, and calling a tool above the session's level answers HTTP 403 insufficient_access with WWW-Authenticate: Bearer error="insufficient_scope" and the scope that allows it.
A Propose app also lists the tools that upload, annotate and propose. Its playlist and screen changes return status: "pending_review" with the review's id and url instead of applying, and a person approves them in the dashboard's Reviews. When the project requires review for agent changes, every app works at Propose at most. To let the app make changes directly, disconnect it and connect it again with Manage.
tools/list returns only the tools the session's access level and capabilities allow. The project's plan entitlements apply on top, exactly as they do for the CLI. Every tool call is an agent request and counts toward the organization's hourly cap.
Connect Claude
In Claude (web, desktop or mobile), add a custom connector with the URL https://api.screenrig.ai/mcp and connect it. Claude opens the consent page.
In Claude Code, add the server, then authenticate from /mcp:
claude mcp add --transport http screenrig https://api.screenrig.ai/mcpConnect ChatGPT
In ChatGPT, create an app (connector) with the server URL https://api.screenrig.ai/mcp and OAuth authentication. ChatGPT opens the consent page when you connect it. ChatGPT can also subscribe to events, such as a screen going offline, and tell you when they happen.
Connect Grok
In Grok on the web, add a custom connector with the server URL https://api.screenrig.ai/mcp. When it asks for an OAuth client ID, enter screenrig-grok-web and leave the client secret empty. Grok opens the consent page.
In Grok Build, add the server URL as a remote HTTP server. Grok Build opens the browser sign-in the first time it uses the server.
Use the server from an API
The Claude, OpenAI and xAI APIs connect to a remote MCP server per request, with an authorization value you supply. Use a service client: ask for a token with resource=https://api.screenrig.ai/mcp, then pass it with the server URL.
curl -s https://api.screenrig.ai/oauth/token \
-u "$SCREENRIG_CLIENT_ID:$SCREENRIG_CLIENT_SECRET" \
-d grant_type=client_credentials \
-d resource=https://api.screenrig.ai/mcp| API | Where the token goes |
|---|---|
| Claude API | authorization_token of the MCP server entry |
| OpenAI Responses API | authorization of the mcp tool |
| xAI API | authorization of the remote MCP tool |
A token from that request works only on /mcp, lasts 10 minutes and acts on the service client's project with its access level and capabilities. Ask for a new one when it expires.
Tools
Every tool name starts with screenrig_. Tool calls run the same handlers as the CLI and REST API, with the same project isolation, plan limits, rate limits, idempotency and revision checks.
Most areas are grouped tools: one tool covers a family of operations at one access level, and its required action argument selects the operation. Each action takes the arguments of that operation, and the action argument's description lists them. A tool name from before the grouping, such as screenrig_campaign_list, still answers for one release; the result's _meta["screenrig/deprecated"] names the replacement.
In the table, a tool name followed by actions in parentheses is a grouped tool, called with one of those actions as its action argument (screen_actions takes the type as action.type); a name alone is a tool of its own.
| Area | Tools |
|---|---|
| Project and agent | project_read (get, capabilities), project_write (update renames the project), agent_status, project_credential_revoke, agent_identity_revoke: ends the agent identity in every project |
| Projects and organizations | project_read (list), project_create, organization_list, organization_rename: need the identity scope; project_change_read (moves), project_write (move): move a project to another organization; project_change_read (deletion_preview), project_write (delete): read what deleting needs, then delete the project for good |
| Service clients | service_client_read (list, get), service_client_write (create, update, key_add, key_remove, secret_add, secret_remove, revoke): servers, scripts and CI jobs that sign in with their own key or secret (see Service clients); changes need the identity scope |
| Fleet links | fleet_link_read (list, get), fleet_link_write (create, update, rotate, delete): one Player URL that turns every device opening it into its own screen |
| Invitations | invitation_write (create invites by email, link makes a link for a person whose address is not known, revoke), invitation_list |
| Screens | screen_list, screen_get, screen_update, screen_screenshot, screen_screenshot_current, screen_write (pair, archive, unarchive, rotate_public_id, replace, play_page, identify, suspend, resume, command_cancel, recovery_confirm), screen_read (commands), screen_actions (toast, reboot, clear_cache, restart_app, update, reload) |
| Browser screens and links | screen_provision: a screen set up by opening a one-time link in a browser instead of entering a pairing code; screen_inspect (link), screen_write (link_create, link_delete): a Player URL for a browser that keeps no storage, such as a vMix or OBS browser source |
| Screen folders | screen_read (folders, folder), screen_write (folder_create, folder_update, folder_delete, move) |
| Fleet actions | screen_actions: one action across screens chosen by ID, tag or screen folder, or on one screen with the selector {"by": "ids", "screen_ids": ["scr_LOBBY"]}; also takes assign, clear_playlist, set_tags, add_tags and remove_tags |
| Schedules and takeover | screen_read (playlist_schedule), screen_actions (set_playlist_schedule, clear_playlist_schedule, takeover, takeover_clear); schedule_calendar: what a screen, folder, tag or campaign plays over up to 93 days, with each level's spans and conflicts (a folder, tag or campaign needs Premium); schedule_import_template: the sheet of columns to fill in; schedule_import_preview, schedule_import_commit: a sheet of schedule rows, checked and previewed, then applied with the preview's fingerprint (see Schedule import) |
| Campaigns | campaign_read (list, get, screens), campaign_write (create, delete, update also pauses and resumes), screen_read (campaigns): why each campaign plays on one screen or not |
| Display power | screen_actions (display, display_clear, set_display_schedule, clear_display_schedule), screen_read (display_schedule) |
| Volume | screen_actions (volume): set a screen's level, mute it, or both |
| Scheduled reboots | screen_read (reboot_schedule), screen_actions (set_reboot_schedule, clear_reboot_schedule): the backend reboots a screen at the start of each weekly window |
| Playlists | playlist_list, playlist_get, playlist_write (create, update, patch), playlist_manage (delete) |
| Playlist pages | playlist_write (page_add, page_replace, page_remove): change one page of a playlist without resending the others |
| Playlist revisions | playlist_read (revisions, revision), playlist_manage (promote_revision): read a playlist's stored revisions; promoting an earlier one makes it current again and needs Premium |
| Page backgrounds | background_read (categories, sets, set, get): the platform's catalog of page backgrounds, each with an ID for a playlist page's canvas |
| Data feeds | feed_get: read a shared data feed once, such as weather, headlines or tides |
| Playlist templates | playlist_write (set_values), playlist_read (instances), playlist_expand: fill in the values of a playlist made from a template and rebuild it from the template's current revision, list the playlists made from a template, and check a template with values without creating anything |
| Schedule change control | screen_inspect (playlist_schedule_preview), screen_read (playlist_schedule_revisions), screen_playlist_schedule_restore, campaign_preview, campaign_read (revisions), campaign_write (restore, promote): preview a schedule or campaign write without making it, read the revision history, put an earlier revision back, and promote a test publish to its real audience |
| Reviews | review_read (list, get), review_withdraw |
| Media | media_list, media_get, media_thumbnail, media_write (update), media_manage (delete), media_read (versions), media_restore, media_manage (version_delete): the version history of a media file |
| Media availability | media_manage (availability): set or clear when dynamic selectors (all, tag, folder) may pick a media file; selector_preview: what a selector matches now, without changing playback |
| Uploads | media_write (upload_create, upload_commit): declare a media file, send its bytes, then commit it; media_write (replace): swap a media item's file and keep its ID; media_write (import): screenRIG fetches a public https address; application_write (upload_create, release_upload_create, upload_commit): the same for a packed application and for a new release of one (see Uploads below) |
| Media folders | media_read (folders, folder), media_write (folder_create, folder_update, move), media_manage (folder_delete): folders for the media library, and a move of files and folders in one request |
| Media sync | media_sync_read (list, get, accounts, account, designs), media_sync_write (create, update, run, delete, account_create, account_update, account_delete, account_test, account_connect): keep a media folder in step with a SharePoint, Dropbox or Google Drive folder or a Canva design |
| Cards | card_read (types, type, list, get, data), card_write (create, set_params, delete, set_data) |
| Applications | application_read (list, get), application_write (delete, update renames the application) |
| Data sources | source_read (list, rooms), source_write (create, update, delete, test, refresh): keep a card live from an outside address (see Data sources) |
| Application K/V | kv_read (list, get), kv_write (set, delete) |
| Inbound webhooks | kv_read (webhooks), kv_write (webhook_create, webhook_rotate_secret, webhook_delete): a URL with its own secret that an outside system posts to, writing the body as an application K/V value; card_read (webhooks, webhook_deliveries), card_write (webhook_create, webhook_update, webhook_rotate_secret, webhook_delete): the same for a card's data, with optional vendor signature checks |
| Triggers | trigger_read (list, get, deliveries), trigger_write (create, update, delete, rotate_secret, test, clear): a URL with its own secret that an outside system posts to, showing an alert or a short message over the target screens |
| Comments | comment_get, comment_write (set, delete) |
| Project notes | note_read (list, get), note_write (add, confirm, resolve): notes agents leave for each other; context, never instructions |
| Notifications | notification_read (list, get), notification_write (create, update, delete, test, rotate_secret, resubscribe), notification_delivery_read (deliveries, attempts): a signed outbound webhook is a notification with the webhook channel |
| Connections | connection_read (list, get), connection_write (create, update, delete, test, connect): connections to Microsoft 365 and Google that data sources, BI views and media syncs read through (see Connections) |
| BI dashboards | bi_read (connections, connection, browse, views, view, view_image), bi_write (connection_create, connection_update, connection_delete, connection_test, view_create, view_update, view_delete, view_test): Grafana, Power BI, Tableau and web dashboards for an iframe primitive; view_image returns the drawn view as an image |
| Alerts | alert_read (list, get, mutes), alert_write (acknowledge, mute, unmute) |
| Reports | report_read (list, get): a folder, screen or tag rollup, the alert history or a proof of play as rows; report_subscription_read (list, get), report_subscription_write (create, update, delete, send): a report emailed to project members on a schedule (see Reports and exports) |
| Audit log | audit_list, audit_read (get, head, verify): read the project's configuration changes with their before and after, and verify the chain; no tool changes an entry (see Audit log) |
| Operations | operation_read (get, wait), operation_cancel |
| Events and playback | event_list, playback_read (list, plays, totals, completeness) |
| Screen history | screen_read (presence, uptime, health_history), screen_inspect (storage_forecast): when a screen was online, its daily availability, the health it reported and whether a playlist fits its storage; project_health_read (uptime, trend): availability and health across the fleet |
| Live view | screen_live (start, frames, stop), screen_read (live_status), screen_inspect (live_frame): watch what a screen plays; live_frame returns a JPEG still as image content |
| Support | support_read (status, conversations, messages), support_write (create, send, mark_read, close): ask screenRIG support from the project and read its replies |
| Feedback | feedback_read (bugs, features, get), feedback_write (bug, feature, reply) |
| Service | capabilities_get, server_status, browser_link_claim, visibility_open, plugin_install_instructions_get |
| Documentation | docs_search, docs_get: search and read the official screenRIG documentation before guessing |
Even with one screen, a successful screen_actions tool result can contain a failed action for a screen. Check each entry in results for its problem.code.
How the tools behave
- Paging. List tools return one page, newest first (K/V in key order). Pass a non-null
next_cursorback asafter(cursoron the tools that name it), with the same filters, for the next page. - Retries. Writes accept an optional
idempotency_key. Reuse it to retry the same write safely; omit it to start a fresh request. Pairing, provisioning, toasts, play pages, screenshots, invitations, invitation links, uploads, imports, project creation, support messages, browser links, operation cancels and feedback require one, and their input schemas say so. - Revisions. Writes accept an optional
revision. A stale revision is refused: read the resource again, reapply the change and retry. - Reviews. Playlist and screen-change tools take an optional
review_note, at most 280 characters, that the reviewer reads. A change that waits for review returns thepending_reviewbody: tell the user it waits for their approval and give them the reviewurl. Amedia_write(update) that changes approved media's tags returns the item withreview_statepending: screens keep its approved tags, and its review appears in Reviews within a few seconds. Amedia_restoretakes the samereview_noteand returns thepending_reviewbody: the media keeps playing its file until a person approves. A change that reaches a screen in a protected folder waits for a second approver at every access level, Manage included. - What plays. A screen plays the top level of one stack that holds: its takeover, the campaigns that reach it (
priority0 to 100, higher first, then the newest), its playlist schedule entries in order, then its assigned playlist, then the default playlist of its nearest screen folder. Campaigns and schedule entries take the same rules as the CLI, includingmonthly,dates,exceptandinteraction.screen_getreportseffective_playlistwithsourcetakeover,campaign,schedule,defaultorfolder.schedule_calendartakesfromandto(at most 93 days apart) and one ofscreen_id,folder_id,tagorcampaign_id: it groups screens with identical stacks and lists each level's spans (plays,partial,outranked,conditional) and conflicts (two campaigns of one priority holding at once, a level that never plays). Campaign writes need Manage access, so a Propose app lists only the campaign read tools; only a campaign that reaches a protected folder becomes a review. - Screenshots.
screen_screenshotwaits for the capture (timeout_seconds, 20 by default, at most 60) and returns it asimage/webpimage content. A capture that arrives late returnstimeoutwith itscapture_id.screen_screenshot_currentreturns the last ready still and itscaptured_attime without asking for a new capture. - Notification rules.
notification_writewithcreateorupdatetakesmin_severity(info,warningorerror),severity(condition to level, such as{"not_playing": "error"}),active_hours(timezone,windows, andoutside,holdordrop) andaudience(the rules of a campaign audience, instead ofscreen_tags).reach_drop(screens,percent) sets how large a drop in a campaign's reach areach_droppedcondition notifies; it is valid only with that condition.reach_droppedandgroup_emptywatch campaigns, soscreen_tagsandaudiencenever limit them. On update,nullclears each. A held or skipped notice appears innotification_delivery_read(deliveries). - Secrets. A tool that creates or rotates a secret, or answers with a signed or sign-in link, returns that value in its answer, and its description says so: upload URLs and headers, the new signing secret from
notification_write(rotate_secret), trigger, key/value webhook and card webhook secrets (trigger_write(update) andcard_write(webhook_update) return a signing secret when they turn signing on), service-client secrets, fleet links, screen links, provisioning links for screens,invitation_write(link), and the sign-in links thatconnection_write(create,connect) andmedia_sync_write(account_create,account_connect) answer with. A secret that is shown once cannot be read again, so store it at once, and hand a returned secret only to the person or system it is for. A fleet link and a screen link stay readable:fleet_link_read(list,get) andscreen_inspect(link) answer with their URL, andscreen_inspect(link) withholds it below Manage access. Every other result keeps secrets out: the remaining list and get tools never show a stored secret, notification results reduce each receiver URL to its origin, and data source results show each secret by name and never its value. - Uploads. MCP carries no file bytes, so a file reaches the project one of two ways. A client that can make an HTTP request, such as one with a shell or a sandbox, declares the file with
media_write(upload_create) (name, type, exact size and SHA-256), sends the bytes itself to the signedupload_urlin the answer with the method and headers it names beforeexpires_at, then callsmedia_write(upload_commit). Any client can callmedia_write(import) with a public https address: screenRIG fetches the file, up to 200 MB and within 60 seconds, and uploads it. The address must answer with the file itself and need no sign-in. A larger file takes the declare, send and commit route, or the CLI. A commit or an import returns an operation, andoperation_read(wait) answers with the media item or the reason the file was refused. These formats are accepted as they are: PNG, JPEG, WebP and GIF images, MP3 audio, and MP4 or WebM video already encoded for screens. MCP does not convert or resize; the CLI does as it uploads.media_write(replace) takes the upload ID of a declared and sent file, and the media keeps its ID. An application goes the same way withapplication_write(upload_create, orrelease_upload_createfor a new release) andapplication_write(upload_commit), using the archive thatscreenrig app packbuilds. Under Propose access a media upload waits for a person's review. - Projects and access. An app that asks for the
identityscope is offered identity access on the consent page, off unless the person turns it on; an app that did not ask cannot be given it. With identity access the connection can list and create the person's projects and manage organizations and service clients:project_read(list),project_create, the organization tools,service_client_writeandagent_identity_revoke. Without it those operations answer HTTP403. Thegetandcapabilitiesactions ofproject_readdo not need identity access. The identity operations' reads need identity access; a change takes Manage access as well, exceptagent_identity_revoke, which Read only access allows. A project a connection creates is not among the projects that connection can act in: the person reconnects the app and chooses it.project_read(list) marks each project within_token, which says whether this connection can act in it. - Revoking.
project_credential_revokedisconnects the agent whose session made the call. It requiresconfirmation: "REVOKE", andallow_last_agent: trueto disconnect the project's last active agent. The project and its content remain. A connected app ends its own session throughhttps://api.screenrig.ai/oauth/revoke, or a person disconnects it on the Access page. - Errors. A refused call returns a tool error whose structured content is the REST API's problem document, with
code,detailandstatus. The result'sscreenrig/resultmetadata carrieshttp_status, andetagorretry_afterwhen the server sent them.
Resources
Project resources expose private metadata and are never cached. The server also provides an HTML UI resource for interactive cards in MCP Apps hosts.
| URI | Contents |
|---|---|
screenrig://project | The authenticated project |
screenrig://screens/{id} | One screen |
screenrig://cards/{id} | One card |
screenrig://card-types/{id} | One card type |
screenrig://playlists/{id} | One playlist |
screenrig://media/{id} | One media item's metadata |
screenrig://applications/{id} | One application |
screenrig://operations/{id} | One asynchronous operation |
Events
The server implements MCP Events with webhook delivery. An app subscribes to an event, and screenRIG POSTs a signed message to the app's HTTPS callback when it happens, so the app can tell you that a screen went offline or a screenshot is ready without polling. Subscribing needs an OAuth session: a connected app or a service client. Read only sessions may subscribe, since events are reads.
| Event | When | Data | Capability |
|---|---|---|---|
screen.offline | A screen stopped reporting | screenId, screenName | screens |
screen.online | A screen came back online | screenId, screenName | screens |
screen.screenshot_ready | A requested screenshot was captured | screenId, screenName, captureId, width, height | screens |
screen.playlist_unavailable | A scheduled playlist cannot be shown | screenId, screenName, playlistId, code | screens |
screen.display_changed | A display power override or schedule changed | screenId, screenName, change | screens |
agent_connection.approved | A person approved an agent's connection or sign-in | agentId | project |
note.added | An agent added a project note | noteId, authorAgentId, aboutId | any |
note.resolved | A project note was resolved, replaced, expired, not confirmed, or its screen or playlist was deleted | noteId, cause | any |
review.requested, review.approved, review.rejected, review.changes_requested | A proposed change waits for a person, or a person approved it, rejected it or asked for changes | reviewId, kind, state, subjectType, subjectId | any |
Data carries ids and states only. Read the full record with a tool, such as screenrig_screen_get or screenrig_screen_screenshot_current.
List and subscribe
events/list returns the events this session may subscribe to, each with an inputSchema and a payloadSchema. Screen events take an optional screenId argument to follow one screen. events/subscribe takes the event, its arguments and the callback:
{
"jsonrpc": "2.0",
"id": 1,
"method": "events/subscribe",
"params": {
"name": "screen.offline",
"arguments": { "screenId": "scr_LOBBY" },
"delivery": {
"mode": "webhook",
"url": "https://receiver.example.com/screenrig",
"secret": "whsec_BASE64_OF_32_RANDOM_BYTES"
},
"ttlMs": 86400000
}
}- The secret is yours:
whsec_followed by base64 of 24 to 64 random bytes. It signs every delivery. - The callback is an HTTPS URL on a public address, with no redirects.
- The result carries the subscription
id(sub_…),refreshBeforeandcursor: null. Deliveries start from now; there is no replay. - Lifetime.
ttlMsasks for 5 minutes to 24 hours; the default is one hour, andnullgets 24 hours. Subscribe again with the same name, arguments and URL beforerefreshBeforeto extend it; the id stays the same, and the result reportsdeliveryStatus. A new secret on a refresh signs alongside the old one for 10 minutes. - Unsubscribe with
events/unsubscribeand the same name, arguments anddelivery.url.
An organization holds up to 100 subscriptions across its projects, and one session may subscribe 120 times an hour. A subscription ends when its session or service client is revoked, its app is disconnected, its person is deactivated or its project is deleted, and its authority is rechecked every 15 minutes.
Verify the callback
The first subscription from a session to a callback URL sends a signed verification POST:
{ "type": "verification", "challenge": "RANDOM_CHALLENGE" }Answer 2xx within 5 seconds with the same challenge as JSON:
{ "challenge": "RANDOM_CHALLENGE" }A failed check answers the subscribe call with JSON-RPC error -32015, whose data.reason is challenge_failed, timeout, connection_refused, tls_error, http_4xx or http_5xx.
Receive deliveries
Each delivery is a POST of one event, at most 256 KiB:
{
"eventId": "evt_EVENT",
"name": "screen.offline",
"timestamp": "2026-10-08T14:02:11Z",
"data": { "screenId": "scr_LOBBY", "screenName": "Lobby" },
"cursor": null
}Deliveries follow Standard Webhooks:
| Header | Value |
|---|---|
webhook-id | The message id. Deduplicate on it or on eventId. |
webhook-timestamp | Unix seconds when it was sent |
webhook-signature | v1, and the base64 HMAC-SHA256 signature; two, separated by a space, while a new secret takes over |
X-MCP-Subscription-Id | The subscription id |
To verify, decode the base64 after whsec_ into the key, compute HMAC-SHA256 over webhook-id, ., webhook-timestamp, . and the raw body, and compare its base64 with each v1, value in constant time. Reject a timestamp more than five minutes from your clock:
import { createHmac, timingSafeEqual } from "node:crypto";
export function verified(secret, headers, rawBody) {
const key = Buffer.from(secret.slice("whsec_".length), "base64");
const id = headers["webhook-id"];
const timestamp = headers["webhook-timestamp"];
if (Math.abs(Date.now() / 1000 - Number(timestamp)) > 300) return false;
const expected = createHmac("sha256", key).update(`${id}.${timestamp}.`).update(rawBody).digest();
return headers["webhook-signature"].split(" ").some((entry) => {
const [version, signature] = entry.split(",");
const given = Buffer.from(signature ?? "", "base64");
return version === "v1" && given.length === expected.length && timingSafeEqual(given, expected);
});
}Answer 2xx quickly. A failed delivery is retried for 15 minutes; 410 Gone or 413 Payload Too Large stops it at once.
Buy through AdCP
A buyer's agent can buy ad time on the networks that invited its project through AdCP, the advertising protocol for buying agents. The buyer path starts with a seller's invitation; see Quickstart.
| Setting | Value |
|---|---|
| URL | https://api.screenrig.ai/adcp/mcp |
| Authentication | Authorization: Bearer <access token> for the buyer's project, from a signed-in agent or a service client with the default resource, with Manage access and the advertising capability |
| Project | ?project=prj_ID, once, when the token carries several projects |
| Without a token | initialize, tools/list and get_adcp_capabilities |
| Buys | Non-guaranteed media buys, priced per completed play. Each completed play is one impression, and a person reviews every creative before it plays. |
The tasks are get_adcp_capabilities, get_products, list_creative_formats, sync_accounts, list_accounts, sync_creatives, list_creatives, create_media_buy, update_media_buy, get_media_buys, get_media_buy_delivery and sync_governance. get_products offers one product for each network slot the project can see. A write takes an idempotency_key, and a repeat within 24 hours returns the first answer.
A missing or invalid token answers 401 with WWW-Authenticate: Bearer realm="https://api.screenrig.ai/adcp/mcp", error="invalid_token". A token without Manage access or the advertising capability answers 403, and so does one that the project's review setting holds to Propose. When the token cannot be checked, the answer is 503 with Retry-After: retry with the same token.
Use the CLI for these
These steps run on your machine or are not tools, so they stay in the bundled CLI:
| Task | CLI |
|---|---|
| Convert and resize media before upload | screenrig media upload converts and resizes a file as it uploads it; MCP uploads a file as it is |
| Pack an application from a directory | screenrig app pack builds the archive that the application upload tools send |
| Follow events live | screenrig events follow (over MCP, poll screenrig_event_list) |
| Export plays as CSV | screenrig playback plays --format csv |
| Enroll a new agent and sign in | screenrig agent enroll --email ADDRESS --organization "NAME" and screenrig login; an MCP client connects with OAuth instead |
| Advertising and billing | screenrig ads and screenrig billing; a buyer's agent uses AdCP |
| Move from another signage system | screenrig migrate scan, screenrig migrate apply |