Skip to main content
Check environment and feature availability before following this guide.
The LithoBlocks (Staging) custom app is available to invited staging testers and calls https://next.api.lithoblocks.com. Its typed template fields are verified on staging. The production app release remains a separate cutover step; this guide does not announce a public marketplace release.

​
Connect and choose a module

  1. Create a staging API key in API Keys with templates:read and messages:create. Add usage:read to inspect credits.
  2. Add LithoBlocks (Staging) to your Make scenario and create a connection with that key. The connection validates it through GET /v1/auth/validate.
  3. Add Compile Template, Send Template, or Send Template (Bulk) and choose a template. The active version determines which fields appear. A linked Dev Slack workspace is required for sends.
Other modules list, get, search and update templates; list/get versions; read organizations and members; read credits and usage; and make an authorized API call. For queues, schedules, destinations and modals, use Make an API Call with the documented /v1/... path and the required scopes.

​
Map template data

Choosing a template loads Template data with one field per input. Nested objects appear as collections; lists have Add item and fields for each item. Map values from earlier modules or enter literals. Changing the selected template reloads the fields. Sample values shown as hints are examples, not defaults that will be sent automatically. Compile first and inspect compiled_message before sending. Compile consumes one staging credit; its output is a JSON string containing Slack blocks. Send posts through LithoBlocks and returns success, message_ts, and channel.

​
Blank values

Verified in Make’s staging editor on 2026-09-07: Missing scalar placeholders remain visible in the compiled text, for example {{note}}. An empty item can likewise leave unresolved item placeholders. Fill fields you intend to display; an empty form field is not an instruction to substitute an empty string. This matches Make’s processing of empty values. The observed input behavior does not justify changing explicit JSON null into an omitted value.

​
Advanced raw JSON

Show advanced settings → Data (raw JSON) accepts the entire data object. When provided, it replaces the typed collection; the two inputs are not merged. Existing scenarios using data retain this path. Leave raw JSON unset to use the typed fields. Template data excludes the outer template_id and destination properties. The raw-JSON staging test preserved explicit null (rendered as the text “null”) and [] (no loop blocks). The typed editor still validates required fields before making a request. For a workflow that must control an empty list or explicit nulls without those form constraints, use Make an API Call and send the complete API body. Always compile and inspect the result before enabling delivery.

​
Send destinations and partial failures

Send Template takes a destination field and value: a channel ID, recipient email, or Slack user ID. Send Template (Bulk) takes 1–100 destination items. Set exactly one destination field per item:
Bulk returns an HTTP 200 envelope even when some destinations fail. Inspect results, total_sent and total_failed, then route failed items separately. Re-running the whole bulk operation can send again to recipients who already received it. Keep search/list modules on separate scenario routes from sends: one bundle per search result can multiply downstream sends.

​
Errors and retry decisions

Errors include a machine code and a request_id for support; scope failures identify required scopes. Fix invalid data, credentials, scopes or credits before another attempt. Compile Template, Send Template and Send Template Bulk each have an optional Idempotency key under advanced settings. Map a stable source-event identifier, such as order-123-shipped, for one intended operation. Leaving the field blank omits the header and preserves existing behavior: every run can spend another credit or send another message. Existing scenarios do not need to change. Reuse the same key and exact serialized JSON body when reconciling a retry. Keys are scoped to the organization and endpoint; /v1 and unversioned forms of that same endpoint share the scope. A completed non-5xx result is replayable for 24 hours. The same key with a different body returns 409; an unfinished operation also returns 409. Incomplete and 5xx outcomes are retained for reconciliation and do not expire automatically. A timeout or Make RuntimeError does not establish whether a write happened. Inspect usage and delivery records, using the request_id, before retrying. Use a new key for an intentional second message, even when its content is identical. Do not use a constant key for every event, generate a fresh key on retries, put sensitive data in keys, or rotate a key to bypass an uncertain result. The field accepts 1–255 printable ASCII characters without spaces. Make an API Call and Make’s HTTP module can still supply Idempotency-Key directly. A keyed bulk replay returns the original whole result, including failed destinations, without sending again. Inspect results and total_failed. After reconciliation, a deliberate retry of only confirmed failed destinations is a new operation with a new key; resending the whole list can duplicate successes. See API idempotency.

​
HTTP and webhook workflows

Make’s HTTP module can call https://next.api.lithoblocks.com/v1/... directly with Authorization: Bearer YOUR_STAGING_API_KEY and Content-Type: application/json. Keep the key in connection storage. A send body contains template_id, data, and one destination. For incoming interactions, create a Make Webhooks → Custom webhook, configure a LithoBlocks destination, and map the configured payload in Make. Signed destination delivery requires a receiver that verifies the signature; do not assume an ordinary Make webhook performs that verification. Use a verifying receiver for signed workflows. See template placeholders, API reference, and connecting Slack for the underlying contracts.