Menu
BigCommerce Admin GraphQL
Run and edit GraphQL queries/mutations against BigCommerce's Admin API for store settings and URL redirects — read GraphQL data and errors with {{<stepReference>.response.data...}} template syntax.
Browse 5 BigCommerce Admin GraphQL actions bigcommerceOn this page
What this connector is
A thin, editable window onto BigCommerce's Admin GraphQL API — the part of the platform (store settings, URL redirects, metafields, channels) that the REST API doesn't cover. Every request is a GraphQL document you can change. If you need products, orders or customers, use the BigCommerce (REST) connector alongside it.
Every action posts to https://api.bigcommerce.com/stores/{storeHash}/graphql.
Connecting
Use the same credentials as the BigCommerce (REST) connector:
- Store Hash — your store identifier (the 6-character string in your Admin URL).
- API Access Token — an Admin API access token, sent as the
X-Auth-Tokenheader.
Create the credentials under Advanced Settings → API Accounts, with the scopes each query or mutation you plan to run needs. If either value is missing, the action fails with an error pointing you there.
Your first call
- Add a step with the Admin GraphQL: Get Store Settings action and name it "Get Store Settings" (reference
getStoreSettings). - Pick your BigCommerce connection and leave the default query as is, or trim it to just what you need, for example
store { name primaryDomain { host } }. - Run the workflow and read the store name in a later step with
{{getStoreSettings.response.data.data.store.name}}. - Check
{{getStoreSettings.response.data.errors}}before relying on the data — see Reading the response and GraphQL errors.
Every action, with its parameters and response fields, is listed in the action reference.
How actions are organised
There are five actions:
- Admin GraphQL: Execute Query — run any query or mutation you write.
- Admin GraphQL: Get Store Settings — a ready-made store settings query.
- Admin GraphQL: List URL Redirects, Create URL Redirect and Delete URL Redirect — ready-made redirect operations.
The four named actions are the same mechanism as Execute Query, pre-loaded with a useful default document.
The editable query/variables pattern
Unlike a typical fixed-input action, each action exposes two inputs:
- GraphQL Query (or GraphQL Mutation) — the document sent to BigCommerce. It is fully editable: add or remove fields, change filters, or replace the operation with any other query or mutation the Admin GraphQL API supports. On the four named actions, leaving it blank falls back to the default.
- Variables — a JSON string of GraphQL variables, for example
{"first": 10}. It is parsed withJSON.parsebefore sending, so it must be valid JSON; invalid JSON fails the step with an "Invalid variables JSON" error.
Use an action as-is for its default behaviour, or rewrite the document to select different fields, add pagination arguments, or run a different operation from the same area of the schema.
Quirks and exceptions
- Execute Query has no default. Its query field is required; the example shown in the editor is only placeholder text, and no variables are sent unless you supply them (an empty
{}goes out). - Get Store Settings has no Variables field, because its default query declares no
$arguments. If you edit the query to take variables, use Execute Query instead. - The redirect actions each ship with both a default document and default variables; edit the variables (not the document) for normal use.
Reading the response and GraphQL errors
Every action returns the same envelope, read from later steps via its Step Reference, written here as <stepReference>:
{{<stepReference>.response.status}}/{{<stepReference>.response.statusText}}— the HTTP status of the call to BigCommerce. It is usually200even when the GraphQL operation failed, because GraphQL reports errors in the body.{{<stepReference>.response.headers.<header-name>}}— a response header.{{<stepReference>.response.data.data.<field path>}}— your queried data. The first.dataunwraps the connector's HTTP envelope; the second is GraphQL's own{ data, errors }wrapper, so you always see.data.databefore the fields your query selected.{{<stepReference>.response.data.errors}}— an array of GraphQL errors (bad field name, validation failure). Check it even when the status is200.
Mutations add a second level of errors: the redirect mutations return an errors { message } list inside their own payload, for example {{createRedirect.response.data.data.redirects.createRedirects.errors}} for a fromPath that already has a redirect. These are distinct from the top-level response.data.errors, so check both.
Pagination
Queries that return connections (such as redirects) take first and after variables and return pageInfo { hasNextPage endCursor }. To get the next page, run the action again with after set to the previous page's endCursor. The default List URL Redirects variables set first and filter.siteId but not after; add it yourself.
Common tasks
Add redirects after a URL change
- Run List URL Redirects (named "List Redirects", reference
listRedirects) with variables{"first": 50, "filter": {"siteId": 1}}to see what already exists. The redirect list is at{{listRedirects.response.data.data.store.redirects.edges}}. - Run Create URL Redirect with variables like the following. Add more entries to
redirectsto create several at once.statusCodeis301for permanent and302for temporary.
{
"input": {
"siteId": 1,
"redirects": [
{ "fromPath": "/old-product-page", "to": { "url": "/new-product-page" }, "statusCode": 301 }
]
}
}
- Read the new id with
{{createRedirect.response.data.data.redirects.createRedirects.redirects.0.entityId}}.
Remove a redirect you just found
- Run List URL Redirects.
- Run Delete URL Redirect with the id from step 1:
{ "input": { "siteId": 1, "entityIds": [{{listRedirects.response.data.data.store.redirects.edges.0.node.entityId}}] } }
- Confirm with
{{deleteRedirect.response.data.data.redirects.deleteRedirects.deletedRedirectEntityIds}}.
Run any other Admin GraphQL operation
Use Admin GraphQL: Execute Query and paste the full document into GraphQL Query and its variables into Variables, for example a metafields or channels query not covered by the other four actions.
Also applies here
Step Name
What it's for
Every step in a workflow gets a name — either one you set or a default based on the connector and action (e.g. "Get Order Details", "Send Welcome Email"). It's shown throughout the UI and in your execution history, and it's also the source for the step's Reference — a camelCase identifier auto-generated from the name (e.g. "Get Order Details" → getOrderDetails) — which is what you actually use in {{...}} expressions to read this step's output from later steps. See Step Reference.
Rules
- Must be at least 2 characters, and 50 characters or fewer.
- Must be unique within the workflow — reusing a name that's already taken will be rejected, with a suggested alternative (e.g.
"Get Order Details 2"). - Can't be empty.
Tips
- Prefer a descriptive, human-readable name over a generic one — "Get Order Details" is easier to work with later than "HTTP Request 2", especially once a workflow has a dozen steps.
- Renaming a step updates every reference to it elsewhere in the workflow automatically.
Step Reference
Syntax
Any input field can reference earlier data using {{expression}}. The expression is evaluated as JSONata — so simple dot-paths and more advanced queries (filters, functions) both work.
Referencing a step's output
Use the step's Reference — a camelCase identifier auto-generated from its Name (e.g. "Get Order Details" → getOrderDetails), shown read-only wherever the step's fields are configured — followed by the field path. Elsewhere in these docs this general pattern is written as {{<stepReference>.field.path}}:
{{getOrderDetails.response.data.id}}
{{getOrderDetails.response.status}}
The raw display name won't work here even though it's what you see in the UI — {{Get Order Details.response.data.id}} isn't valid, since a bare name containing spaces isn't a single JSONata identifier. Always use the camelCase Reference.
You can also reference steps by position instead of by reference:
{{steps[0].response.data.id}}
Referencing trigger data
{{trigger.headers.authorization}}
{{trigger.body.customerId}}
{{trigger.query.page}}
{{trigger.params.orderId}}
{{trigger.method}}
{{trigger.path}}
Referencing workflow variables
{{variables.myVariable}}
See Variables for the full list of variable types and more examples, including connection-type variables.
Referencing runtime variables
A separate, mutable namespace written by the Variable connector while a run is in progress — not the same as the workflow-level variables above:
{{runtimeVariables.myVariable}}
Notes
- If an expression can't be resolved (a typo in a step name, a field that doesn't exist), it resolves to an empty string rather than failing the workflow — check your execution history if a value comes through blank.
- Object values are automatically JSON-stringified when interpolated into a string field.
Execution Settings
Fire-and-forget
When enabled, the workflow doesn't wait for this step to complete before moving to the next one. Use it for steps whose result nothing downstream depends on — logging, analytics, notifications — so they don't add latency to the steps that matter.
Continue on error
When enabled, a failure in this step doesn't stop the workflow — execution continues to the next step. The failure is still recorded in the execution history; this just controls whether it's fatal.
Combine the two for steps that are genuinely optional to the outcome: fire-and-forget so they don't add latency, continue-on-error so a failure in them (e.g. an analytics endpoint being briefly down) doesn't take down an otherwise-successful workflow run.
Caching
What it does
When enabled, a step's result is cached for a configurable TTL (time-to-live, in seconds). If the step runs again with the same effective cache key before the TTL expires, the cached result is returned instead of re-running the step.
Configuring it
- Enabled — turn caching on or off for this step.
- TTL — how long (in seconds) a cached result stays valid.
- Cache key template — an expression (supporting the same
{{...}}step reference syntax used elsewhere) that determines what counts as "the same call". By default this is based on the step's resolved input; a custom template lets you cache more narrowly or broadly than that.
When to use it
Good candidates are steps that call something slow or rate-limited but return the same answer for the same input within a short window — a lookup against a rarely-changing external system, for example. Skip it for steps whose result must always be fresh (anything involving live inventory, pricing, or payment state).
Locking
What it does
When enabled, only one execution of this step (for a given lock key) can run at a time. If a second execution tries to run the same step while a lock is held, it waits until the lock is released or the hold period elapses.
Configuring it
- Enabled — turn locking on or off for this step.
- Lock key — an expression (supporting the same
{{...}}step reference syntax used elsewhere) that determines what counts as "the same resource". By default the lock is scoped to the step itself; a custom key lets you lock per-customer, per-order, or any other identifier that needs serialized access. - Period — how long (in seconds) the lock is held before it's automatically released, in case an execution doesn't complete normally.
When to use it
Use it whenever concurrent executions could race on the same resource — e.g. two workflow runs both trying to update the same order's status at once. A lock key scoped to the order id ensures only one of them proceeds at a time.
Last updated 9 October 2026