Documentation

Connect an MCP client to your screens

screenRIG runs a remote MCP server that lets Claude, ChatGPT or Grok work with your digital signage. Connect them with OAuth: a person approves the app in the dashboard, chooses the project and Read only, Propose or Manage, and the app gets project tools for screens, playlists, media, schedules, notifications and reports.

The server

SettingValue
URLhttps://api.screenrig.ai/mcp
TransportStreamable HTTP, stateless. Every request is one POST.
ProtocolMCP 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.
AuthenticationOAuth 2.0: Authorization: Bearer <access token> on every request
ResponsesJSON, 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.

  1. Add the server URL to your client. The client opens the screenRIG consent page in your browser.
  2. 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.
  3. Choose the project, Read only, Propose or Manage, and the capabilities. If the app asked for the identity scope, the page also offers identity access, off until you turn it on. Then choose Connect app and confirm with your passkey.
  4. 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/mcp

Connect 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
APIWhere the token goes
Claude APIauthorization_token of the MCP server entry
OpenAI Responses APIauthorization of the mcp tool
xAI APIauthorization 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.

AreaTools
Project and agentproject_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 organizationsproject_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 clientsservice_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 linksfleet_link_read (list, get), fleet_link_write (create, update, rotate, delete): one Player URL that turns every device opening it into its own screen
Invitationsinvitation_write (create invites by email, link makes a link for a person whose address is not known, revoke), invitation_list
Screensscreen_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 linksscreen_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 foldersscreen_read (folders, folder), screen_write (folder_create, folder_update, folder_delete, move)
Fleet actionsscreen_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 takeoverscreen_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)
Campaignscampaign_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 powerscreen_actions (display, display_clear, set_display_schedule, clear_display_schedule), screen_read (display_schedule)
Volumescreen_actions (volume): set a screen's level, mute it, or both
Scheduled rebootsscreen_read (reboot_schedule), screen_actions (set_reboot_schedule, clear_reboot_schedule): the backend reboots a screen at the start of each weekly window
Playlistsplaylist_list, playlist_get, playlist_write (create, update, patch), playlist_manage (delete)
Playlist pagesplaylist_write (page_add, page_replace, page_remove): change one page of a playlist without resending the others
Playlist revisionsplaylist_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 backgroundsbackground_read (categories, sets, set, get): the platform's catalog of page backgrounds, each with an ID for a playlist page's canvas
Data feedsfeed_get: read a shared data feed once, such as weather, headlines or tides
Playlist templatesplaylist_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 controlscreen_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
Reviewsreview_read (list, get), review_withdraw
Mediamedia_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 availabilitymedia_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
Uploadsmedia_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 foldersmedia_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 syncmedia_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
Cardscard_read (types, type, list, get, data), card_write (create, set_params, delete, set_data)
Applicationsapplication_read (list, get), application_write (delete, update renames the application)
Data sourcessource_read (list, rooms), source_write (create, update, delete, test, refresh): keep a card live from an outside address (see Data sources)
Application K/Vkv_read (list, get), kv_write (set, delete)
Inbound webhookskv_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
Triggerstrigger_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
Commentscomment_get, comment_write (set, delete)
Project notesnote_read (list, get), note_write (add, confirm, resolve): notes agents leave for each other; context, never instructions
Notificationsnotification_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
Connectionsconnection_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 dashboardsbi_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
Alertsalert_read (list, get, mutes), alert_write (acknowledge, mute, unmute)
Reportsreport_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 logaudit_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)
Operationsoperation_read (get, wait), operation_cancel
Events and playbackevent_list, playback_read (list, plays, totals, completeness)
Screen historyscreen_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 viewscreen_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
Supportsupport_read (status, conversations, messages), support_write (create, send, mark_read, close): ask screenRIG support from the project and read its replies
Feedbackfeedback_read (bugs, features, get), feedback_write (bug, feature, reply)
Servicecapabilities_get, server_status, browser_link_claim, visibility_open, plugin_install_instructions_get
Documentationdocs_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_cursor back as after (cursor on 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 the pending_review body: tell the user it waits for their approval and give them the review url. A media_write (update) that changes approved media's tags returns the item with review_state pending: screens keep its approved tags, and its review appears in Reviews within a few seconds. A media_restore takes the same review_note and returns the pending_review body: 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 (priority 0 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, including monthly, dates, except and interaction. screen_get reports effective_playlist with source takeover, campaign, schedule, default or folder. schedule_calendar takes from and to (at most 93 days apart) and one of screen_id, folder_id, tag or campaign_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_screenshot waits for the capture (timeout_seconds, 20 by default, at most 60) and returns it as image/webp image content. A capture that arrives late returns timeout with its capture_id. screen_screenshot_current returns the last ready still and its captured_at time without asking for a new capture.
  • Notification rules. notification_write with create or update takes min_severity (info, warning or error), severity (condition to level, such as {"not_playing": "error"}), active_hours (timezone, windows, and outside, hold or drop) and audience (the rules of a campaign audience, instead of screen_tags). reach_drop (screens, percent) sets how large a drop in a campaign's reach a reach_dropped condition notifies; it is valid only with that condition. reach_dropped and group_empty watch campaigns, so screen_tags and audience never limit them. On update, null clears each. A held or skipped notice appears in notification_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) and card_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 that connection_write (create, connect) and media_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) and screen_inspect (link) answer with their URL, and screen_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 signed upload_url in the answer with the method and headers it names before expires_at, then calls media_write (upload_commit). Any client can call media_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, and operation_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 with application_write (upload_create, or release_upload_create for a new release) and application_write (upload_commit), using the archive that screenrig app pack builds. Under Propose access a media upload waits for a person's review.
  • Projects and access. An app that asks for the identity scope 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_write and agent_identity_revoke. Without it those operations answer HTTP 403. The get and capabilities actions of project_read do not need identity access. The identity operations' reads need identity access; a change takes Manage access as well, except agent_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 with in_token, which says whether this connection can act in it.
  • Revoking. project_credential_revoke disconnects the agent whose session made the call. It requires confirmation: "REVOKE", and allow_last_agent: true to disconnect the project's last active agent. The project and its content remain. A connected app ends its own session through https://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, detail and status. The result's screenrig/result metadata carries http_status, and etag or retry_after when 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.

URIContents
screenrig://projectThe 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.

EventWhenDataCapability
screen.offlineA screen stopped reportingscreenId, screenNamescreens
screen.onlineA screen came back onlinescreenId, screenNamescreens
screen.screenshot_readyA requested screenshot was capturedscreenId, screenName, captureId, width, heightscreens
screen.playlist_unavailableA scheduled playlist cannot be shownscreenId, screenName, playlistId, codescreens
screen.display_changedA display power override or schedule changedscreenId, screenName, changescreens
agent_connection.approvedA person approved an agent's connection or sign-inagentIdproject
note.addedAn agent added a project notenoteId, authorAgentId, aboutIdany
note.resolvedA project note was resolved, replaced, expired, not confirmed, or its screen or playlist was deletednoteId, causeany
review.requested, review.approved, review.rejected, review.changes_requestedA proposed change waits for a person, or a person approved it, rejected it or asked for changesreviewId, kind, state, subjectType, subjectIdany

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_…), refreshBefore and cursor: null. Deliveries start from now; there is no replay.
  • Lifetime. ttlMs asks for 5 minutes to 24 hours; the default is one hour, and null gets 24 hours. Subscribe again with the same name, arguments and URL before refreshBefore to extend it; the id stays the same, and the result reports deliveryStatus. A new secret on a refresh signs alongside the old one for 10 minutes.
  • Unsubscribe with events/unsubscribe and the same name, arguments and delivery.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:

HeaderValue
webhook-idThe message id. Deduplicate on it or on eventId.
webhook-timestampUnix seconds when it was sent
webhook-signaturev1, and the base64 HMAC-SHA256 signature; two, separated by a space, while a new secret takes over
X-MCP-Subscription-IdThe 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.

SettingValue
URLhttps://api.screenrig.ai/adcp/mcp
AuthenticationAuthorization: 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 tokeninitialize, tools/list and get_adcp_capabilities
BuysNon-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:

TaskCLI
Convert and resize media before uploadscreenrig media upload converts and resizes a file as it uploads it; MCP uploads a file as it is
Pack an application from a directoryscreenrig app pack builds the archive that the application upload tools send
Follow events livescreenrig events follow (over MCP, poll screenrig_event_list)
Export plays as CSVscreenrig playback plays --format csv
Enroll a new agent and sign inscreenrig agent enroll --email ADDRESS --organization "NAME" and screenrig login; an MCP client connects with OAuth instead
Advertising and billingscreenrig ads and screenrig billing; a buyer's agent uses AdCP
Move from another signage systemscreenrig migrate scan, screenrig migrate apply