Menu
Acumatica
Work with Acumatica customers, vendors, stock items, sales orders, shipments, invoices and more. Covers Connected Application setup, the endpoint version, OData options and the value wrapper.
Browse 51 Acumatica actions Acumatica · GenericRequestOn this page
Connecting Acumatica
Every action needs an Acumatica connection that uses OAuth 2.0 client credentials:
- In Acumatica open Connected Applications (SM303010) and add an application using the Client Credentials flow. Copy its Client ID and Secret.
- Create the connection with your Instance URL (for example
https://yourcompany.acumatica.com), the Client ID, the Client Secret, and the token URL. The token URL is filled in as<instance>/identity/connect/token. - On a multi-tenant instance, add
@TenantNameto the Client ID.
The instance URL is the host every request goes to. If your instance is served from a site path (for example https://host/AcumaticaDB), include it.
Endpoint and version
Actions use Acumatica's Default web service endpoint at version 24.200.001, so requests go to <instance>/entity/Default/24.200.001/.... If your instance runs a different version or uses a custom endpoint, choose Custom in an action's Base URL field and enter the path, for example /entity/Default/23.200.001. You can look up the endpoints your instance offers under Web Service Endpoints (SM207060).
Every action, with its parameters and response fields, is listed in the action reference.
What's covered
Customers, Vendors, Stock Items, Sales Orders, Shipments, Sales Invoices, Purchase Orders, Bills, Payments, Inventory Receipts, Contacts and Warehouses. Each has list and get actions; all except Warehouses also have a create-or-update action and a delete action. Anything else, including custom endpoints, entity actions such as releasing a document, and other entities, is reached with the Generic Request actions.
Query options
List and get actions accept the OData options Acumatica supports:
$filter— for exampleStatus eq 'Open'.$select— limit the fields returned.$expand— include detail rows, for exampleDetailson a sales order.$topand$skip— page through results.$custom— include custom fields.
Request bodies and values
Create-or-update actions take a single JSON Body field. Acumatica wraps every field value in an object with a value key:
{
"CustomerID": { "value": "ABARTENDE" },
"CustomerName": { "value": "Acme Bar and Grill" }
}
Sending the key fields of an existing record updates it; otherwise a new record is created. Get and delete actions take the record id — either its GUID, or its key values as Acumatica expects them in the URL, such as order type and number for a sales order.
Reading the response
Every action's result is at {{<stepReference>.response...}} (see Step Reference). Values come back in the same wrapper as requests:
- A list —
{{<stepReference>.response.data}}is the array of records. - A single record —
{{<stepReference>.response.data.CustomerName.value}}. - A delete — status
204; confirm with{{<stepReference>.response.status}}.
A step named "List Customer" has reference listCustomer, so the first name is {{listCustomer.response.data[0].CustomerName.value}}. An error status fails the step; the status and body are in the step's error details.
Your first call
- Add an Acumatica step and choose List Customer; name it
listCustomer. - Set
$topto10and run it. - Read
{{listCustomer.response.data[0].CustomerID.value}}.
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 12 November 2026