
adobe-for-developers
Search the developer.adobe.com docs. Manage Adobe Developer Console projects, workspaces, APIs, and credentials. Create and test I/O Events registrations and subscriber defined filters.
- version
- 1.0.0
- GitHub stars
- 332
Install
/plugin install adobe-for-developers@adobe-skillsRun it inside Claude Code after adding the marketplace with /plugin marketplace add adobe/skills.
Contents
Discovered from sourceSkills 7
Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.
Console Context Navigator
Track and display the user's current location in Adobe Developer Console. Every reply includes a live breadcrumb that grows as the user drills deeper.
Breadcrumb format
Always place this on the very first line of every reply:
📍 [Org: {orgName} ({orgId})]
📍 [Org: {orgName} ({orgId})] › [Project: {projectName} ({projectId})]
📍 [Org: {orgName} ({orgId})] › [Project: {projectName} ({projectId})] › [Workspace: {workspaceName} ({workspaceId})]
📍 [Org: {orgName} ({orgId})] › [Project: {projectName} ({projectId})] › [Workspace: {workspaceName} ({workspaceId})] › [Credential: {credentialName} ({credentialType}) ({credentialId})]
Rules:
- Start with only what's confirmed — never show a placeholder or "unknown"
- Grow the breadcrumb as each level is selected, never shrink it
- Show name and ID together (e.g.
My Org (12345)) — never show just raw IDs alone - If the user changes selection at any level, update from that level forward
Project information requests
Use this flow whenever the user asks for information about a particular project:
- Reuse confirmed organization and project context. Resolve only missing context with
get_organisationsorget_projects. If the user names a project without its ID, useget_projectswithfilterBy: "all"to find it; ask for a selection only if the target is ambiguous. - Call
get_project_by_idwithorgIdandprojectId. It pulls in profile information for the users who created or modified the project. - Show the requested details from that response: project name/title, description, type, enabled/deleted status, creation/modification dates, and creator/modifier information when present. Do not infer missing details.
- For an information-only request, stop at project level. Do not fetch workspaces or credentials unless the user also asks for them.
Navigation flow
Step 1 — Org
Call get_organisations. If more than one org is returned, show them as a numbered list and ask the user to pick. If only one, select it automatically and note: "Using org: {orgName}".
Step 2 — Project
If the user wants to create a new project, do not list existing projects; hand off to dev-console-create-project, preserving the selected org context.
For project-information requests, use the flow above instead of project browsing.
Follow the shared option-selection rules to resolve project reuse, creation, and empty results.
When a project lookup is needed, call get_projects with filterBy: "all" unless the user asked for only their projects (filterBy: "me"). An empty "mine" result does not establish that the organization has no projects.
For project browsing:
- Sort the returned projects by
date_last_modified, newest first. Put missing or invalid dates last without inventing timestamps. - Show at most 10 projects per batch as a clean numbered list (title + last modified date, no raw IDs). State the displayed range and total, for example "Showing 1-10 of 27 projects, most recently modified first."
- Offer "Show more" only when unseen projects remain. On request, show the next batch of up to 10 projects with continuous numbering; do not repeat earlier entries.
get_projectsreturns an array; retain that response for the selected organization and filter and reuse it for subsequent display batches rather than refetching. Restart browsing when the organization or filter changes.- Resolve a project named by the user against the entire returned list, not just the displayed batch. Likewise, use the full result for empty-list and single-option decisions.
Step 3 — Workspace
Reuse a confirmed workspace selection or workspace details returned by project creation; otherwise call list_workspaces for the chosen project. If only one workspace is returned (default projects always have a single Production workspace), select it automatically without asking. If multiple workspaces exist, show them as a numbered list and ask the user to pick.
Step 4 — Credential (optional)
If the user wants to go deeper, call get_credentials for the chosen workspace. For each credential also call get_credential_services to show subscribed APIs. Include, for each credential: name, type, client ID (if applicable), and subscribed APIs (or "none yet"). The layout below is a reference for content, not a literal template — adjust formatting as needed for the client:
🔑 Credential: "My S2S Cred" (OAuth Server-to-Server)
Client ID: xxxxxxxxxxxxxxx
APIs: Adobe Analytics, Firefly API
🔑 Credential: "My Web Cred" (AdobeId / WebApp)
APIs: none yet
Ask the user which credential to work with, or say "none" to stay at workspace level.
Context summary
Once the full context is set, summarize it for the user before proceeding — org, project, workspace, and credential (if selected), each with name and ID together. Box-drawing layouts like the one below don't render reliably in every client (e.g. Claude Desktop), so treat it as a reference for what to include, not a literal template to reproduce — a plain list or short paragraph is fine:
📍 Console Context
Org: My Org Name (12345)
Project: My Project (111222333444555666)
Workspace: Production (777888999000111222)
Credential: My S2S Cred (OAuth S2S) (99001)
When Instructions Are Unclear
If the user references an Adobe concept, project type, or Console feature you're unsure about — call search_adobe_docs before asking for clarification. For example:
- Unsure what a project type means → search "Adobe Developer Console project types App Builder default"
- User mentions a workspace concept you don't recognise → search "Adobe Developer Console workspace"
- Unclear what a credential field means → search "Adobe Developer Console credential {field name}"
Always prefer fetching from official docs over guessing.
Rules
- If the user says something like "switch project" or "go back", reset from that level and re-navigate
- This skill sets context — it does not subscribe APIs. For subscribing, hand off to
/dev-console-subscribe-apiwith the established context
Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.
Create Project
Create and initialize an Adobe Developer Console project in the user's selected organization. Both project types use the same flow and the same create_project tool; only the projectType argument differs.
Steps
-
Resolve the project type from explicit user signals — Use only explicit instructions for the project being created, from the current request or earlier conversation. Follow the most recent explicit instruction:
- The user explicitly requests "App Builder" or a "template" project →
projectType: "appBuilder". - The user explicitly requests a default/empty project or rejects App Builder/templates →
projectType: "default". - No explicit App Builder/template request for this project →
projectType: "default".
Never infer App Builder from requested APIs, credentials, runtime features, project names, other skills, or prior projects. Unrelated or negated mentions of "App Builder" or "template", including documentation discussions, do not count as a request. Do not ask the user to choose or confirm the project type.
Steps 2–5 are identical for both types.
- The user explicitly requests "App Builder" or a "template" project →
-
Select an organization — Reuse the org if it has already been selected in this request. Otherwise call
get_organisations. If multiple organizations are returned, show their names as a numbered list and ask the user to choose. If only one is returned, select it automatically and tell the user which organization will be used. Keep IDs internal; use the selected organization'sidasorgId. -
Resolve project naming — Follow the shared naming rules.
-
Create and initialize the project — Call
create_projectonce with the selectedorgId,name,title, and theprojectTypefrom step 1. Do not pass a template ID or workspace details; the tool sets up the project for the chosen type:- Default project: creates the project with its default workspace.
- App Builder template project: creates the project from the App Builder template together with Production and Stage workspaces, both with runtime enabled.
-
Report the result — On success, explicitly state the created project's title and type:
- Default: "Created {title} as a default project."
- App Builder: "Created {title} as an App Builder template project, with Production and Stage workspaces, both with runtime enabled."
Retain the returned
projectIdand any workspace IDs for follow-up, but do not display raw IDs. If the response does not include workspace details, calllist_workspacesfor the created project. If the response includesconsole_url, display it as:🔗 View in Adobe Developer Console: {console_url}
If the user also wants to subscribe an API, continue with dev-console-subscribe-api skill using the created org, project, and workspace context. For an App Builder template project with more than one workspace, ask which workspace to use (Production or Stage) unless the user already said. Do not ask the user to select or re-enter IDs already returned by project creation.
Rules
- This skill creates a project only; it does not create credentials or subscribe APIs.
- Do not call
create_projectuntil the project type, organization, and project name are known. - Do not ask for custom workspace names, descriptions, or template choices; the connector does not accept them.
- If project creation reports that Adobe Developer Terms have not been accepted, ask the user to review the terms and explicitly confirm agreement before calling
accept_developer_terms. Then retry project creation once. - Do not claim success if the tool returns an error or an ambiguous result.
Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.
Subscribe API Flow
Guide the user through subscribing an Adobe API to a credential in an existing project, step by step.
Before starting: invoke the dev-console-context skill to establish the org, project, and workspace. If the user wants a new project, invoke dev-console-create-project first and continue with the context it returns. After the workspace is selected or created, call get_credentials and immediately call get_credential_services for each returned credential before presenting the credentials and their subscriptions. Do not repeat these calls if the context skill already made them during this request.
Steps
-
Find the API — If the user asks "what APIs are available", "show me available APIs", or similar, call
list_serviceswithfilterBy: "enabled"and display only the enabled APIs as a list (name + description, no raw codes). If the user named a specific API, calllist_serviceswithfilterBy: "enabled"to find itscodeand full details. Never guess an SDK code. -
Pick credential type — Always validate against the API's supported types — never skip this check because an existing credential was found. An API can have multiple enabled instances with different
typevalues. Collect ALL enabled instances for the API code. Reuse a type already specified by the user if it is supported; otherwise:- Include
admin_entpinstances as Admin Enterprise credentials; do not filter them out or redirect the user to Console for creation or subscription. - If only one credential type → proceed with it automatically, including when that type is Admin Enterprise.
- If multiple credential types → show them as a numbered list and ask: "This API supports multiple credential types. Which would you like to use?"
- Analytics credential (internal:
analytics) — if ananalyticsinstance is present - User Auth (AdobeId) — for user-facing apps (internal:
adobeid) - OAuth Server-to-Server — for server-to-server access (internal:
oauth_server_to_server, also used forentp) - Admin Enterprise (internal:
admin_entp) — if anadmin_entpinstance is present
- Analytics credential (internal:
- Wait for the user to pick when multiple supported types remain unresolved. Do not auto-select based on what credentials already exist in the workspace.
- Show only credential type names in this list — never mention existing credentials here. Do not append "subscribe to the existing X credential" or any reference to existing workspace credentials. Existing credential lookup happens after the type is chosen.
- Include
-
Check for product profiles — After the credential type is decided, inspect its
properties.licenseConfigsarray from the matching API instance:- If it is non-empty: present the profiles as a numbered list (show
name, never rawidorproductId) and tell the user: "You can select one or more of these profiles." Collect their choices — you'll need the selected profiles'idandproductIdfields when subscribing. - If it is empty or absent: continue with no
licenseConfigs. - This step must complete before any credential creation or subscription call — even when creating a new credential. Never pass
servicestocreate_oauth_s2s_credentialuntillicenseConfigshave been resolved.
- If it is non-empty: present the profiles as a numbered list (show
-
Subscribe — Use a credential of the selected type from the chosen workspace. If several matching credentials exist, ask the user to choose by credential name. If none exists, create one using Credential creation inputs below. For a newly created project, use the selected workspace ID from the creation/context flow for every credential creation and subscription call. For an App Builder project, preserve the user's Production or Stage selection; never replace a selected Stage workspace with Production. Automatically use Production only for a default project with a single workspace. If no workspace has been selected, use the returned workspace details or call
list_workspacesto resolve the selection before proceeding. If the selected type is User Auth (AdobeId), calllist_workspacesto confirm the selected workspace before creating that credential; this confirmation must not change the user's selection.Admin Enterprise credential (
admin_entp):- For a new credential, call
create_admin_enterprise_credentialwithorgId,projectId,workspaceId, the creation inputs below, andservicesincluding any product profiles selected in step 3. This creates the credential and subscribes the API in one call. - For an existing credential, call
subscribe_admin_enterprise_credential_to_serviceswithorgId,credentialId, andservicesincluding any product profiles selected in step 3. No project or workspace ID is required by this tool; choose only a credential from the selected workspace. - Pass only the services to add or change. The connector fetches existing subscriptions and merges them before calling the replacement PUT endpoint, preserving other APIs. For an already-subscribed SDK code, include all intended license configs and roles (existing plus new), because that service's settings are replaced.
update_admin_enterprise_credentialchanges only the credential's name, description, and redirect settings; it does not add, replace, or remove API subscriptions. Never call it to subscribe an API or report a subscription success based on its response.- Do not pass
admin_entptosubscribe_credential_to_services; that tool does not support it.
OAuth Server-to-Server credential (
oauth_server_to_server) → callsubscribe_credential_to_services:- Pass
orgId,projectId,workspaceId,credentialType: "oauth_server_to_server",credentialId, andservices. - Each service entry must include
licenseConfigsif the user selected product profiles in step 3. An emptylicenseConfigs: []is NOT the same as omitting it — pass the user's selections. - The
credentialTypemust always match the credential's actual type (oauth_server_to_server), never the API's type (entp).
Other credential types (
adobeid,analytics,entp,oauth_server_to_server) usesubscribe_credential_to_services(PUT). The server automatically preserves all already-subscribed services — only pass the service(s) you want to add or change; do NOT pre-fetch and re-send the full existing list. Preservation is per-service, not per-licenseConfig: if you're adding a licenseConfig to an already-subscribed service, include that service's full intended licenseConfigs list (existing plus new), not just the new one. - For a new credential, call
-
Report success — If the subscription tool succeeds, report success without a separate verification call. For Admin Enterprise service tools, the DTO-derived JSON body uses
sdkList,error, anderrorDetails(noterrorList). HTTP 200 can contain partial failures: the connector returns an MCP error if either error array is non-empty, including the failed SDK codes and returned SDK list. Some changes may already have applied; inspect current subscriptions before retrying and never automatically retry the whole list. For Admin Enterprise creation, inspectsubscriptionResultwhen present; do not report an API as subscribed if it appears inerrorListor its subscription is otherwise unconfirmed. "✓ [API name] has been successfully subscribed to your [credential type] credential." List the APIs confirmed by the response. The services array may contain only additions, so do not present it as the full current list. Only callget_credential_servicesif the response is ambiguous or an error was returned.
Credential creation inputs
When no credential exists and one must be created, apply the Common Skill Rules for names, titles, and descriptions. Preserve valid user-supplied values; otherwise derive the missing name using the pattern {projectName}-{type}[-{subtype}], without a naming prompt:
| Credential type | Platform / subtype | Auto-generated name example |
|---|---|---|
| OAuth S2S | — | mcptesting-s2s |
| Admin Enterprise | — | mcptesting-admin-enterprise |
| AdobeId | WebApp | mcptesting-adobeid-webapp |
| AdobeId | SinglePageApp | mcptesting-adobeid-singlepageapp |
| AdobeId | NativeApp | mcptesting-adobeid-native |
| AdobeId | apiKey | mcptesting-adobeid-apikey |
| Analytics | Web | mcptesting-analytics-web |
| Analytics | iOS | mcptesting-analytics-ios |
| Analytics | Android | mcptesting-analytics-android |
For a missing description, use: "{Type} credential for {projectTitle}" (e.g. "OAuth S2S credential for mcptesting").
For generated names, use lowercase letters, digits, and hyphens, and truncate to 50 characters if needed. Do not silently modify user-supplied values; follow the shared validation and fallback rules.
OAuth Server-to-Server (create_oauth_s2s_credential)
- Use the name and description resolved above. No further input needed — proceed directly to creation.
- Never pass
servicestocreate_oauth_s2s_credential— always create the credential first (noservices), then subscribe in a separatesubscribe_credential_to_servicescall. Inline service attachment is unreliable and causes confusing retry flows.
Admin Enterprise (create_admin_enterprise_credential)
- Use the name and description resolved above.
- Ask for
defaultRedirectUri(the OAuth callback URL) andredirectUriPattern(the regex for allowed redirect URIs). Never invent placeholder values or use an unrestricted pattern by default. - Pass the selected API in
services, including product profiles selected in step 3. Do not make a separate subscription call after successful inline subscription.
User Auth — AdobeId (create_user_auth_credential)
- Use the name and description resolved above.
- Resolve platform from the matching API instance's
platformList, when provided, and documented API support.1. WebApp — web application 2. SinglePageApp — SPA/React/Angular app 3. NativeApp — desktop or mobile app 4. apiKey — server-side API key access
Before asking for platform, if available_scopes is present:
- Display a table of available scopes and tell the user: "All scopes are granted by default and cannot be deselected."
Platform-specific inputs — NEVER invent placeholder values, always wait for the user:
WebApp/SinglePageApp: ask for both:defaultRedirectUri— plain URL (e.g.https://example.com/callback)redirectUriList— one or more redirect URI patterns; pass as plain URLs, the server escapes dots automatically
NativeApp: no extra inputs required — proceed directly.apiKey: ask fordomain. No redirect URI needed.
Analytics (create_analytics_credential)
- Use the name and description resolved above.
- Resolve platform from the matching API instance's
platformList, when provided, and documented API support. Filter the following platform labels before offering a choice:1. Web — web app 2. iOS — iOS mobile app 3. Android — Android mobile app
Platform-specific inputs — NEVER invent placeholder values:
Web: ask for both:defaultRedirectUri— plain URL (e.g.https://example.com/callback)redirectUriList— one or more redirect URI patterns; pass as plain URLs, the server escapes dots automatically
iOS: ask forurlScheme. No redirect URI needed.Android: no extra inputs required — proceed directly.
After creating a credential that needs a separate subscription call, use its returned id as credentialId. Admin Enterprise creation already includes the requested services. Never re-fetch credentials after a fresh creation.
Whenever any tool response includes a console_url field (credential creation or subscription), always display it to the user as a clickable link:
🔗 View in Adobe Developer Console: {console_url}
When Instructions Are Unclear
If you're unsure about an API, credential type, product profile, or Adobe concept during this flow — call search_adobe_docs before asking the user to clarify. For example:
- User asks to subscribe an API you don't recognise → search "Adobe {API name} API developer documentation"
- Unclear what scopes or product profiles an API requires → search "Adobe {API name} OAuth scopes product profile"
- Unsure which credential type fits the user's use case → search "Adobe Developer Console credential types OAuth S2S user auth"
Always prefer fetching from official docs over guessing.
Rules
entpAPIs (e.g. Adobe Campaign) use an OAuth S2S credential. Never show "entp" to the user.admin_entpinstances are selectable as Admin Enterprise credentials. Usecreate_admin_enterprise_credentialfor creation with inline services andsubscribe_admin_enterprise_credential_to_servicesto add or update APIs on existing credentials. API removal is handled bydev-console-unsubscribe-apiskill.update_admin_enterprise_credentialonly updates credential details and does not change subscriptions.- Always use the API
typefield to determine credential type. Completely ignoreoauthServerToServerOnly. Mapping:adobeid→create_user_auth_credential,analytics→create_analytics_credential,entp→create_oauth_s2s_credential,oauth_server_to_server→create_oauth_s2s_credential,admin_entp→create_admin_enterprise_credential. - Never skip step 2. Credential type must be chosen based on the API's supported types every time — not inferred from what credentials already exist in the workspace.
- Never show raw IDs (licenseConfigId, credentialId, productId) to the user — use names instead.
- Integrations and credentials are the same concept. The
get_credentialsresponse usesid_integrationas the credential ID — use this value wherevercredentialIdis required in any tool call.integration_nameis the credential's display name. - Never use internal jargon — present
licenseConfigsas "product profiles" to the user. - Never skip product profile selection. If
properties.licenseConfigsis non-empty for an API, always complete step 3 and include the selectedlicenseConfigsin theservicesarray — both when subscribing to an existing credential and when creating a new one. An omitted or emptylicenseConfigsmeans the subscription will have no product profile attached. list_servicesreturns a very large payload that exceeds the inline token limit. When you need to find an API code or inspect its details, search the saved file with a shell command (e.g.python3 -c "import json; ..."filtering by name/code) rather than reading the full response inline.
Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.
Unsubscribe API Flow
Remove one or more API subscriptions from a credential in the selected workspace.
Before starting: invoke the dev-console-context skill to establish the org, project, and workspace context, reusing any selected credential. Otherwise, resolve the credential here: list credentials in the selected workspace and inspect each with get_credential_services before offering a selection. Offer only credentials subscribed to the requested API, or credentials with any subscription if no API was specified.
Steps
-
Confirm the target — Resolve the requested API or APIs from
get_credential_services; ask for a selection only if the target is unresolved. Show API, credential, and project names only; never show raw IDs or SDK codes. Only offer currently subscribed APIs. If none match the request, report that without offering an unsubscription. -
Explain the change and request approval — Before calling a tool, summarize the API name(s), credential name, and project name that will be affected, and say that the change has no automatic undo. Do not ask the user to type a name or provide a typed confirmation. The client's Yes/No approval prompt is the confirmation.
-
Remove the subscription:
- For credential types
adobeid,analytics,entp, andoauth_server_to_server, callunsubscribe_credential_from_servicewithorgId,projectId,workspaceId, the credential's actualcredentialType,credentialId, and the selected API'ssdkCodeinsdkCodes. - For Admin Enterprise (
admin_entp), callunsubscribe_admin_enterprise_credential_from_servicewithorgId,credentialId, and oneserviceitem containing the selected API'ssdkCodeplus any required subscription settings. Use the existing subscription details; do not invent settings. Make one call per API so the client can approve each removal separately. - Never emulate unsubscription by sending a reduced service list to a subscription or update tool. For OAuth Server-to-Server, always use
unsubscribe_credential_from_service; it selects the dedicated upstream unsubscribe path. - If the user declines a client approval prompt, stop without retrying or working around it.
- For credential types
-
Report the result — Report removal only when the tool confirms success. For Admin Enterprise, inspect the returned
statusandbodyfor failures before claiming success. For other credential types, use the tool's returnedremainingAPIs when available; do not make a verification call unless the response is ambiguous or an error occurred.
Rules
- Use the credential's actual type, not the API's type. In particular, an API with type
entpmay be subscribed to an OAuth Server-to-Server credential. - For Admin Enterprise,
update_admin_enterprise_credentialchanges credential details only; it cannot remove an API subscription. - If an API's identity or required Admin Enterprise subscription settings are unclear, inspect the available subscription details or call
search_adobe_docs. Never guess an SDK code or settings.
Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.
I/O Events — Filtering & Sample Events
Before starting: invoke the io-events-registration skill.
Sample Events Flow
Trigger when the user asks about sample events, wants to test their registration, or says things like "show me a sample event", "test my registration", "what does the event look like", "send a test event".
Step 1 — Check availability
Call check_sample_event with providerId and eventCode.
- If
{ available: false }→ tell the user: "No sample event is available for this event type." and stop. - If
{ available: true }→ proceed to Step 2.
Step 2 — Ask the user
"A sample event is available. Would you like to: 1. View the sample payload 2. Send it to your registration as-is (for testing) 3. Send a custom version of it (edit the payload before sending) 4. All of the above"
Step 3a — View sample payload
Call get_sample_event with providerId and eventCode. Display the result:
📦 Sample Event
Format: cloud_events_v1
Payload:
{
"specversion": "1.0",
"type": "ai_cloud_docs_deleted",
...
}
Step 3b — Send to registration (as-is)
Call get_registrations_for_workspace to fetch existing registrations. Show as a numbered list and ask the user to pick one:
1. My Journal Reg (journal) ID: reg-abc123
2. My Webhook Reg (webhook) ID: reg-def456
Call post_sample_event with providerId, eventCode, registrationId and no custom payload.
- If
{ posted: true }→ "✓ Sample event sent to your registration successfully." - If
{ posted: false }→ "This event type does not support posting sample events."
Step 3c — Send a custom event
Call get_sample_event to fetch the sample payload (if not already done in Step 3a).
To determine the format, use event_delivery_format from the provider returned by list_event_providers — not the format field on the sample payload.
CloudEvents format (event_delivery_format === "cloud_events_v1"):
Parse sample_payload as JSON and show the user every field — marking type and source as read-only (Adobe enforces these server-side):
📦 Sample Event — customise before sending:
Editable:
specversion: "1.0"
id: "abc-123"
time: "2026-06-30T10:00:00Z"
datacontenttype: "application/json"
data: { ... }
Read-only (set by Adobe):
type: "{type value}"
source: "{source value}"
Change any editable field and I'll send it.
Wait for the user's changes. Build the final payload by merging their edits with the canonical type and source from the original sample.
Other formats (event_delivery_format is not "cloud_events_v1"):
Show the full sample_payload as editable — user can change any field including envelope fields. No restrictions apply.
Once ready, confirm before sending:
I'll send this custom event to your registration. Proceed?
Call get_registrations_for_workspace if a registration hasn't been selected yet → show list → user picks.
Call post_sample_event with providerId, eventCode, registrationId, and payload set to the merged payload.
- If
{ posted: true }→ "✓ Custom event sent to your registration successfully." - If
{ posted: false }→ "This event type does not support posting sample events."
Subscriber Filter Flow
Trigger when user says "add filter", "create filter", "subscriber filter", "filter events", "define filter", "filter registration", "validate filter".
Subscriber Defined Filters use AWS Event Ruler JSON syntax to match against event payloads. Only events that match the filter reach the registration's endpoint.
Step F1 — Resolve registration context
If consumerOrgId, projectId, workspaceId are not already known, invoke the io-events-registration skill Step 1 first.
Call get_registrations_for_workspace to get all registrations. Then validate eligibility:
Step F1a — Filter by delivery type
Exclude any registration with delivery_type: "aws_eventbridge" — AWS EventBridge handles its own filtering natively.
Step F1b — Validate CloudEvents v1 format
For the remaining registrations, collect all unique provider_id values from their events_of_interest. Call list_event_providers with consumerOrgId and imsOrgCode to get provider details.
For each provider, check its event_delivery_format field:
"cloud_events_v1"→ eligible ✅"adobe_io"→ not eligible — Subscriber Defined Filters are not supported for the Adobe I/O format ❌- Any other value (or missing) → not eligible ❌
A registration is fully eligible if all its providers use "cloud_events_v1".
A registration is partially eligible if only some providers do — show it but warn that events from "adobe_io" providers will be delivered unfiltered.
A registration is ineligible if none of its providers use "cloud_events_v1" — exclude it.
Step F1c — Show eligible registrations
Eligible: 1. My Journal Reg (journal) 2. My Webhook Reg ⚠️ (webhook)
Not eligible: ✗ My EventBridge Reg (aws_eventbridge)
Ask the user to pick from the eligible list only.
If no eligible registrations exist, tell the user:
Subscriber Defined Filters are only supported for journal, webhook, and runtime action
registrations whose events use the CloudEvents v1 format.
None of your current registrations are eligible. Create an eligible registration first.
If the user picks a partially eligible registration, warn before proceeding:
⚠️ One or more providers in this registration do not use CloudEvents v1 format.
Filters will only apply to events from eligible providers.
Events from other providers will be delivered unfiltered.
Step F1d — Check for existing filter
Call get_subscriber_filters on the selected registration. Only one filter is allowed per registration.
-
If a filter already exists → tell the user:
⚠️ This registration already has a Subscriber Defined Filter: Name: {name} Expression: {subscriber_filter} Only one filter is allowed per registration. Would you like to update the existing filter instead?If yes → redirect to the Update Filter Flow (Step U3, skipping U1 and U2). If no → stop.
-
If no filter exists → proceed to Step F2.
Step F2 — Introduce the DSL and show available patterns
Call get_subscriber_filter_patterns to retrieve all supported patterns.
Explain briefly: Adobe I/O Events uses the AWS Event Ruler DSL — you write a JSON expression matched against each event's payload, and only matching events are delivered.
Show the patterns as a numbered list using the name from each entry. Ask which pattern the user would like to use.
Step F3 — Show the example for the chosen pattern
Find the entry in the get_subscriber_filter_patterns response whose name matches what the user picked. Display its value as formatted JSON:
Here is an example for "{patternName}":
{value as pretty-printed JSON}
Then ask:
"Would you like to create a filter like this for your registration, or combine multiple patterns?"
Step F3.5 — Offer a sample event payload for reference
After showing the pattern example, ask:
"Would you also like to see a real sample event payload? This can help you identify the exact field names to use in your filter."
If the user says yes:
- From the registration selected in Step F1, get the
events_of_interestlist (callget_event_registrationif not already in context). - If multiple event types, show them as a numbered list and ask which one to preview.
- Call
check_sample_eventwithproviderIdandeventCode.- If
{ available: false }→ "No sample payload is available for this event type." - If
{ available: true }→ callget_sample_eventand display:
- If
📦 Sample Event Payload
Format: {format}
Payload:
{sample_payload as pretty-printed JSON}
Use the field names from this payload in your filter expression.
Top-level CloudEvent fields (specversion, id, source, type, datacontenttype, time)
can be referenced directly. Event-specific data lives under the "data" key.
- Proceed to Step F4.
Step F4 — User writes the filter expression
Ask:
"Write your filter expression in Event Ruler JSON. Conditions on different fields are implicitly AND-ed together."
If the user is unsure, offer to help build it field by field:
"What field in the event payload do you want to filter on? (e.g.
data.status,type,source)"
Step F5 — Validate the filter
Call validate_subscriber_filter with:
consumerOrgId,projectId,workspaceId,registrationIdfrom contextsubscriber_filter: an object withname: "validation-check"andsubscriber_filter: the user's expression string
If validation succeeds (200):
✓ Your filter expression is valid!
It will match events where:
{plain-English summary of the filter}
Would you like to go ahead and create this filter?
If validation fails (400):
✗ The filter expression has an issue:
{error message from the API}
Please correct the expression and try again.
Return to Step F4 if the user wants to fix it.
Step F6 — Resolve filter metadata
Once the user confirms creation in Step F5, apply the shared naming rules using the validated filter's conditions as context.
Step F7 — Create the filter
Call create_subscriber_filter with consumerOrgId, projectId, workspaceId, registrationId, name, description, and subscriber_filter.
Report:
✓ Subscriber filter created!
Name: {name}
ID: {id}
Expression: {subscriber_filter}
Events that match this filter will now be delivered to registration "{registrationName}".
Managing existing filters
| User intent | Action |
|---|---|
| "show my filters" / "list filters" | Call get_subscriber_filters → display as numbered list with name, ID, expression |
| "view filter" / "get filter details" | Call get_subscriber_filter with the filter ID |
| "delete filter" / "remove filter" | Run the Delete Filter Flow below |
Delete Filter Flow
Step D1 — Pick registration
Call get_registrations_for_workspace → show all registrations. Ask the user to pick one.
Step D2 — Show available filters
Call get_subscriber_filters. Display as a numbered list:
Filters on "{registrationName}":
1. My Status Filter (ID: 497f6eca-…) {"data":{"status":[{"equals":"published"}]}}
If no filters exist → "This registration has no subscriber filters to delete." and stop.
Step D3 — Announce the deletion
Once the user picks a filter, tell them which one is about to be deleted and that it can't be undone:
"This will permanently delete the filter {name} from {registrationName}."
Do not ask them to type the filter name. The client shows its own Yes / No approval prompt when you call the tool; that prompt is the confirmation.
Step D4 — Delete
Call delete_subscriber_filter with consumerOrgId, projectId, workspaceId, registrationId, and subscriberFilterId. If the user declines the approval prompt, stop — do not retry or work around it — and ask what they would like to do instead.
Report: "✓ Filter "{name}" deleted successfully."
Update Filter Flow
Step U1 — Pick registration
Call get_registrations_for_workspace → show all registrations. Ask the user to pick one.
Step U2 — Pick filter
Call get_subscriber_filters. Display as a numbered list. If no filters exist → redirect to Step F2.
Step U3 — Show current filter and pick a new pattern
Display the current filter, then call get_subscriber_filter_patterns and show the pattern list as in Step F2.
Step U4 — Show pattern example — same as Step F3. Optionally offer a sample event payload (Step F3.5).
Step U5 — User writes the new filter expression — same as Step F4.
Step U6 — Validate — same as Step F5. Loop back to Step U5 if invalid.
Step U7 — Preserve or explicitly update metadata
Apply the shared naming rules for metadata updates. If a requested metadata change is ambiguous, ask only for the missing information.
Step U8 — Call update
Call update_subscriber_filter with consumerOrgId, projectId, workspaceId, registrationId, subscriberFilterId, name, description, and the new subscriber_filter.
Report:
✓ Subscriber filter updated!
Name: {name}
ID: {subscriberFilterId}
Expression: {subscriber_filter}
When Instructions Are Unclear
If the user's intent is ambiguous or a concept needs clarification — call search_adobe_docs before asking the user. For example:
- Unsure how AWS Event Ruler syntax works → search "Adobe I/O Events subscriber defined filter AWS Event Ruler syntax"
- User mentions a filter pattern you don't recognise → search "Adobe I/O Events filter pattern {pattern name}"
- Unclear what CloudEvents fields are available for filtering → search "Adobe I/O Events CloudEvents v1 payload fields"
Always prefer fetching from official docs over guessing.
Rules
- Only one Subscriber Defined Filter is allowed per registration — always call
get_subscriber_filtersbefore creating and redirect to update if one already exists - Subscriber Defined Filters only work on registrations with
event_delivery_format: "cloud_events_v1"— providers with"adobe_io"format or AWS EventBridge registrations are not eligible - For CloudEvents sample events:
typeandsourceare read-only (enforced by Adobe) — all other fields includingdataare editable
Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.
I/O Events Registration Flow
Guide the user through creating an event registration to receive events from Adobe services.
Before starting: invoke the dev-console-context skill.
Steps
Step 1 — Org, Project, Workspace
-
Call
get_organisations→ ask user to pick org. Store bothid(numeric) andcode(IMS org code). -
Ask: "Do you want to use an existing project or create a new one?"
If existing project:
- Call
get_projectswithfilterBy: "me"→ show as numbered list → user picks project.
If new project:
- Invoke
dev-console-create-projectand reuse its returnedprojectIdand workspace context directly. A default project has a single Production workspace; an App Builder template project has Production and Stage, so ask the user which one to use unless they already said.
- Call
-
For existing projects: call
list_workspaces→ auto-select if only one workspace (Production), otherwise ask user to pick.
Step 2 — Pick event provider
Call both in parallel:
list_event_providerswith bothconsumerOrgId(orgidfield) andimsOrgCode(orgcodefield)get_provider_metadatawithimsOrgCode(the orgcodefield)
Map and enrich:
- From
list_event_providers, collect the uniqueprovider_metadatavalues across all returned providers. - Filter
get_provider_metadataresults to only those whoseidmatches one of the collectedprovider_metadatavalues — discard the rest. - For display, use the enriched metadata (
group,label,description,type) for the filtered entries only.
Show the enriched list grouped by group — only providers actually available to this org:
Creative Cloud:
1. Adobe Illustrator Cloud Docs — OAuth S2S or User Auth
Adobe Services:
2. Adobe Admin Console Audit Logs — OAuth S2S only
Credential type display — map providerMetadata.type field:
entp→ show "OAuth S2S only"adobeid→ show "User Auth only"entp_and_adobeid→ show "OAuth S2S or User Auth"
Ask the user to pick one provider category.
After picking, if has_multiple_providers: true → show instances (from list_event_providers filtered by providerMetadataId) and let the user pick one or more. If has_multiple_providers: false → auto-select the single instance.
Step 3 — Pick event types
For each selected provider id, call list_provider_events.
Combine all returned event types. Show and ask user to pick one or more:
1. Cloud Doc Deleted (ai_cloud_docs_deleted)
2. Cloud Doc Created (ai_cloud_docs_created)
3. Cloud Doc Updated (ai_cloud_docs_updated)
Step 4 — Pick credential
Use the type from the selected provider metadata to determine which credential types are valid:
Provider metadata type | Valid credentials to show |
|---|---|
entp | OAuth S2S only |
adobeid | User Auth (AdobeId) only |
entp_and_adobeid | Both OAuth S2S and User Auth |
4a. Ask credential type first (based on provider type):
- If
entp→ skip asking, proceed with OAuth S2S automatically - If
adobeid→ skip asking, proceed with User Auth automatically - If
entp_and_adobeid→ ask:This provider supports multiple credential types. Which would you like to use? 1. OAuth Server-to-Server 2. User Auth (AdobeId)
4b. If OAuth S2S selected:
- Call
get_credentialsand check if one exists (flow_type: "entp"orintegration_type: "oauth_server_to_server") - If exists → use it, call
get_credential_secretswithid_integrationto getclient_id - If not → follow the OAuth S2S credential creation steps from the
dev-console-subscribe-apiskill (### OAuth Server-to-Serversection), then callget_credential_secrets
4c. If User Auth selected:
Ask for platform: WebApp, SinglePageApp, NativeApp, or apiKey.
- Call
get_credentialsand check if a User Auth credential exists for that platform (flow_type: "adobeid") - If exists → use it, call
get_credential_secretsto getclient_id - If not → follow the User Auth credential creation steps from the
dev-console-subscribe-apiskill (### User Auth — AdobeIdsection) for the chosen platform, then callget_credential_secrets
Step 5 — Pick delivery type
Ask the user to pick one delivery type:
How would you like to receive events?
1. Journal — poll events from a journal endpoint (Adobe manages the queue)
2. Webhook — push events to a URL in real time
3. AWS EventBridge — deliver events to AWS
4. Runtime Action — invoke an App Builder runtime action
If Journal selected: no extra inputs needed.
If Webhook selected:
- Ask for webhook URL
- Ask: "Single events or batches?" → Single =
"webhook", Batch ="webhook_batch"
If AWS EventBridge selected:
- Ask for AWS Region and AWS Account ID
delivery_type: "aws_eventbridge", goes intodestination_metadata: { aws_region, aws_account_id }
If Runtime Action selected:
- Ask for runtime action path (e.g.
my-org/my-app/my-action) - Goes into top-level
runtime_actionfield
Step 6 — Resolve registration metadata
Apply the shared naming rules.
Step 7 — Create registration
One create_event_registration call for the delivery type the user picked. Use consumerOrgId, projectId, workspaceId, client_id, name, optional description, events_of_interest, enabled: true.
| Delivery | delivery_type | Extra fields |
|---|---|---|
| Journal | "journal" | — |
| Webhook | "webhook" or "webhook_batch" | webhook_url |
| AWS EventBridge | "aws_eventbridge" | destination_metadata |
| Runtime Action | "journal" | runtime_action |
Note: Adobe automatically provisions a journal in the background for non-journal registrations — do not create a separate journal registration unless the user explicitly chose Journal.
Step 8 — Report success
✓ Event registration created successfully!
Provider: {providerLabel}
Events: {event_codes}
Credential: {credentialName} ({credentialType})
Delivery: {delivery_type}
Registration: {name} (ID: {registration_id})
If delivery_type is webhook or webhook_batch, check webhook_status in the response:
verified→ all good, Adobe confirmed the endpoint.verification_pending→ Adobe hasn't sent the challenge yet or the endpoint hasn't responded. Tell the user:⏳ Webhook verification is pending. Adobe will send a GET request with a `challenge` query param to your URL. Your endpoint must respond with the `challenge` value to complete verification. Run `get_event_registration` in a few moments to check the status.verification_failed→ offer to re-trigger (see Webhook Verification Flow below).
If delivery_type is journal, tell the user:
📋 Your journal registration is ready. Events will queue here as they arrive.
Use the Journal Reading Flow to fetch them with `get_journal_events_batch`.
Journal Reading Flow
Trigger when user says "read journal", "fetch events", "poll journal", "get journal events", "what events came in", "show me my events", "read from journal".
Journal is pull-based. Unlike webhook/runtime/AWS EventBridge (push), the consumer fetches batches on demand. Adobe queues events; you drain them.
- If workspace context is not set, run Step 1 first.
- Call
get_registrations_for_workspace→ filter todelivery_type: "journal"→ show as numbered list → user picks one. - Call
get_credentials→ match the registration'sclient_idto a credential'sclient_id→ use itsid_integrationascredentialId. - Ask: "Start from the beginning, the latest event, or a specific position (
sincecursor)?"- Beginning / default → call
get_journal_events_batchwithconsumerOrgId,imsOrgCode,credentialId,registrationId. - Latest → call with
latest: true. - Cursor → ask for the
sincevalue → pass assince.
- Beginning / default → call
- Display results:
- If empty → "No events in the journal yet. Events will appear once the source produces them."
- If events found → show a compact summary, then offer to fetch more:
Fetched {count} event(s): 1. {type} {time} source: {source} Fetch more?
- If the user wants more, call
get_journal_events_batchagain with thesincecursor from the previous response's_links.nextlink.
Tracing Flow
Trigger when user says "trace events", "debug delivery", "check event delivery", "why didn't I receive events", "event trace".
Tracing is push-based only. Applicable to
webhook,webhook_batch,aws_eventbridge, andruntime_actionregistrations. Journal registrations have no delivery attempts to trace.
- If workspace context is not set, run Step 1 first.
- Call
get_registrations_for_workspace→ filter outdelivery_type: "journal"→ show remaining registrations → user picks one. - Call
get_credentials→ matchclient_id→ useid_integrationascredentialId. - Call
get_tracing_for_registrationwithconsumerOrgId,imsOrgCode,credentialId,registrationId. - Display results:
- If empty array → "No trace events found — no events have been delivered to this registration yet."
- If traces found → show as a table:
Date Event Code Status 2026-06-20T10:00:00 ai_cloud_docs_deleted delivered
Add Event Providers to Existing Registration
Trigger when user says "add more events", "add another provider", "subscribe to more events", "add event type", "extend registration", "add provider to registration".
A registration can cover multiple providers and event types. Adding more must go through
update_event_registration— never create a new registration for this.
Step A1 — Pick registration
Call get_registrations_for_workspace → show as numbered list → user picks one.
Step A2 — Show current events
Call get_event_registration to fetch the full registration. Display what's already subscribed:
Current events on "{name}":
1. {providerLabel} — {event_code}
2. {providerLabel} — {event_code}
Step A3 — Pick new provider
Follow Step 2 (Pick event provider) from the main flow to let the user pick a new provider and event types. Skip any providers/event codes already in events_of_interest.
Step A4 — Pick new event types
Follow Step 3 (Pick event types) for the newly selected provider.
Step A5 — Confirm
I'll add the following to "{name}":
+ {providerLabel} — {event_codes}
Existing subscriptions are preserved. Proceed?
Step A6 — Update
Call update_event_registration with all existing fields from Step A2 plus the new entries appended to events_of_interest.
Report:
✓ Registration updated!
Name: {name}
Events: {all event_codes, old + new}
Delete Registration Flow
Trigger when user says "delete registration", "remove event registration", "unsubscribe from events".
- If the user hasn't specified which registration, call
get_registrations_for_workspaceand show the list. - Once the user picks one, tell them which registration is about to be deleted and that it can't be undone: "This will permanently delete registration {name}." Do not ask them to type the name. The client shows its own Yes / No approval prompt when you call the tool; that prompt is the confirmation.
- Call
delete_event_registrationfor the chosen registration. If the user declines the approval prompt, stop — do not retry or work around it — and ask what they would like to do instead. - Report: "✓ Registration '{name}' deleted successfully."
Webhook Verification Flow
Trigger when:
- The user says "webhook verification failed", "re-verify webhook", "retry webhook", "webhook status failed", "webhook not verified", "webhook challenge", "re-trigger webhook"
- You see
webhook_status: "verification_failed"in any registration response
How it works: Calling update_event_registration with the same fields re-triggers Adobe's challenge flow.
Step V1 — Identify the registration
Call get_registrations_for_workspace → filter to webhook/webhook_batch registrations with webhook_status: "verification_failed" → show as numbered list → user picks one. Auto-select if only one.
Step V2 — Show status and explain
⚠️ Webhook verification failed for "{name}"
Webhook URL: {webhook_url}
Status: verification_failed
Adobe sent a GET challenge request to your webhook URL but did not receive
the correct response. Your endpoint must echo back the `challenge` query
parameter value in the response body.
Would you like me to re-trigger the verification challenge now?
Step V3 — Re-trigger the challenge
Call get_event_registration to fetch the full current registration.
Then call update_event_registration with the exact same values as the current registration:
consumerOrgId, imsOrgCode, projectId, workspaceId, registrationId ← from context
name, description, webhook_url, events_of_interest, delivery_type, enabled ← from current registration
Step V4 — Confirm and advise
✓ Webhook verification re-triggered!
Adobe will now send a new challenge GET request to:
{webhook_url}
Your endpoint must respond with:
HTTP 200
Body: the value of the `challenge` query parameter
Run `get_event_registration` in a few seconds to confirm the status
changes from `verification_pending` → `verified`.
When Instructions Are Unclear
If the user's intent is ambiguous, a concept is unfamiliar, or you need more context about an Adobe product or API before proceeding — call search_adobe_docs with the relevant question before asking the user to clarify. For example:
- Not sure what delivery type fits the user's use case → search "Adobe I/O Events delivery types comparison"
- Unclear what credential type a provider requires → search "Adobe I/O Events credential types entp adobeid"
- User mentions a product you don't recognise → search "what is {product} Adobe developer platform"
Always prefer fetching from official docs over guessing.
Rules
- Use
patch_event_registrationfor targeted changes (enable/disable, rename, change webhook URL) - Use
update_event_registrationwhen changing multiple fields at once (events, delivery type, etc.) - JSON Patch path examples:
"/enabled","/name","/webhook_url","/delivery_type" - Use
providerMetadata.typeto determine valid credential types — never offer credential types not supported by the provider - Only create one registration — the delivery type the user explicitly chose
- A registration can include events from multiple providers — if the user wants to add more providers to an existing registration, use the Add Event Providers to Existing Registration flow (
update_event_registration); if they explicitly want a new separate registration, proceed with the main creation flow - Never create an extra journal registration alongside another delivery type — Adobe provisions one in the background automatically
- For
journaldelivery, remind the user to use the Journal Reading Flow (get_journal_events_batch) to fetch events - Tracing only applies to push-based registrations — never call
get_tracing_for_registrationfor a journal registration - When
webhook_status: "verification_failed"is seen on any registration, proactively flag it and offer the Webhook Verification Flow - To re-trigger webhook verification, call
update_event_registrationwith the exact same fields — always fetch the current registration first viaget_event_registration
Mandatory prerequisite: Before starting this skill, read and apply Common Skill Rules.
Search Adobe Developer Docs
Retrieve grounded answers from official Adobe developer documentation. This skill is a retriever — passages are fetched and returned for you to synthesize into a final answer. Do not answer from training knowledge alone.
When to invoke
- Any question about Adobe developer products, APIs, SDKs, or platform concepts
- Before starting a provisioning flow (credential creation, API subscription, I/O Events setup) — gather context first
- When the user explicitly asks to search Adobe documentation
Flow
Step 1 — Check if scoped to a specific product
Does the user mention a specific product (e.g. "search only App Builder docs", "look this up in Express Add-ons docs")?
- Yes → Call
list_doc_collectionsto get available collection IDs. Match the user's product to acollectionId. Proceed to Step 2 with thatcollectionId. - No → Proceed to Step 2 with no
collectionId(searches all collections).
Step 2 — Retrieve passages
Call search_adobe_docs with:
query: the user's question or topic as-iscollectionId: from Step 1 (omit to search all)numberOfResults: 5 (default) — increase to 10 if the question is broad
Step 3 — Handle results
Results found:
Synthesize the answer from the returned passages. For each passage used, cite the source:
{Your synthesized answer}
Sources:
- {title} — {sourceUrl}
- {title} — {sourceUrl}
Zero results:
Tell the user no documentation was found and suggest rephrasing or broadening the query. If offering collection scopes, first reuse or call list_doc_collections and use only returned collection names; omit that suggestion if none are available:
No results found for "{query}". Try:
- Rephrasing with different keywords
- Using a broader search term
- Scoping to a specific collection (e.g. App Builder, Express Add-ons)
Then offer to retry with a rephrased query.
Rules
- Never answer Adobe documentation questions from training knowledge alone — always call
search_adobe_docsfirst - Always cite source URLs from the returned passages
- Synthesis happens here in the LLM — the tool only retrieves; do not ask the tool to generate answers
- If the user asks about a product not covered by any collection, tell them the available collections (from
list_doc_collections) and suggest the closest match
Hooks 1
MCP servers 1
Sponsors
Details
- Marketplace
- adobe/skills
- Source
- plugins/adobe-for-developers
- Author
- Adobe
- Category
- Development
- License
- Apache-2.0
- Keywords
- adobe, adobe-developer-platform, developer-console, credentials, io-events, documentation, mcp
More from adobe/skills
All 19- aem-6-5-ltsv1.0.0
- aem-cloud-servicev1.4.4
- aem-edge-delivery-servicesv1.3.2
- aem-eds-content-opsv1.3.1
- aem-eds-personalizationv1.0.0
- aem-forms-edge-delivery-servicesv1.0.1
- aem-project-managementv1.0.1
- app-builderv1.0.0
- commerce-app-management
- commerce-app-migration
- commerce-app-reviewv1.0.0
- run-workflowv1.0.0
- semrushv1.0.0
- stardustv0.39.4
- webv1.0.0
- workfrontv2.0.0
- adobe-analyticsv1.0.0
- adobe-cjav1.0.1