> ## Documentation Index
> Fetch the complete documentation index at: https://docs.ohmyho.st/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> For account actions, read https://ohmyho.st/skills/ohmyhost-get-started/SKILL.md and use the authenticated ohmyho.st CLI, local product MCP or supported remote OAuth MCP. Read the current project source binding before choosing GitHub or managed versions. Mintlify search only reads documentation. Preserve the customer’s selected project, environment and authentication provider; keep private application values in the one-hour secret link or local stdin flow.

# Connect Make

> Ask your ohmyho.st agent to connect Make and find the connection you want to use.

Connect Make once in your ohmyho.st workspace. Your agent can use that authorization to find the Make connections available to you across projects in the workspace. Credentials stay in the connection service.

## Connect your account

In your chat, ask your ohmyho.st agent to connect your Make account. It checks for an active workspace grant with `integration_connection_list` and creates a private consent link with `integration_connection_begin` if needed. Open the link as the same ohmyho.st user, review and approve the permissions in Make, then return to the chat. If prompted after approval, select **Save connection** before returning.

To start from the CLI, use your saved login and workspace.

```sh theme={null}
ohmyhost connection begin \
  --organization ORGANIZATION_ULID \
  --idempotency-key make-connect-1 \
  --profile-name PROFILE_NAME --json
```

Open the returned URL privately and approve access on Make. Use the request ID to check the handoff.

```sh theme={null}
ohmyhost connection status \
  --organization ORGANIZATION_ULID \
  --request REQUEST_ID \
  --profile-name PROFILE_NAME --json
```

`consumed` means the portal accepted the link. Check `connection list` for an `active` grant to verify that Make is connected.

## Find a connection in chat

For example, tell your agent:

> Help me connect a SaaS tool to my application using Make. Ask me which tool I want to use, then find its connection.

Your agent reuses your active workspace grant. It uses `integration_connection_discover` to list Make organizations, then teams within each relevant organization, then connection names and IDs in those teams. It can use an organization or team you already named to narrow the search. If it finds one clear match, it can identify the connection right away. When several match, it can show their names and teams so you can choose. If the names do not identify the integration, tell the agent the connection name you see in Make.

Discovery works before you have a project. It reads connection metadata. Running a Make action needs an imported connection and a binding, described below.

```sh theme={null}
ohmyhost connection list \
  --organization ORGANIZATION_ULID \
  --profile-name PROFILE_NAME --json

ohmyhost connection discover \
  --organization ORGANIZATION_ULID \
  --grant GRANT_ULID \
  --profile-name PROFILE_NAME --json
```

Discovery returns organizations first. Repeat it with `--provider-organization ID` to list that organization's teams, then add `--team ID` to inspect the team's connections.

Discovery finds organizations across Make zones and reads team and connection metadata from the selected organization's zone.

Make controls its OAuth token lifetimes. The service refreshes a valid grant as needed. A grant that can no longer refresh requires consent again. The grant persists across portal logins, and access depends on the linking user's current workspace rights.

## Request a new Make connection

If your team needs a new connection, ask your agent to create a Make Credential Request. A workspace owner selects the Make organization and team, then names the standard apps and exact published module or Endpoint IDs to authorize. Use discovery to find the right organization and team in Make. If the choice is ambiguous, include the Make zone in your request. ohmyho.st takes the zone from the selected Make organization.

> Create a Make Credential Request for Google Sheets v2, using the `getValues` and `updateValues` Endpoints in my selected Make team.

The agent calls `integration_credential_request_create` with the active workspace grant. Make determines the credentials and provider scopes needed for the selected actions and returns a private authorization link. Open it in Make and follow Make's instructions. Keep the link private and enter credentials only on Make. The request can be created before you choose a project. [Make Credential Requests](https://developers.make.com/api-documentation/api-reference/credential-requests) · [Make Endpoints SDK](https://developers.make.com/make-sdk/make-endpoints-sdk)

From the CLI, provide the workspace and grant IDs and the Make organization and team IDs found through discovery. Each selection includes the app name and version, with explicit `module_ids`, `endpoint_names`, or both.

```sh theme={null}
ohmyhost connection credential-request-create \
  --organization ORGANIZATION_ULID \
  --grant GRANT_ULID \
  --provider-organization MAKE_ORGANIZATION_ID \
  --team TEAM_ID \
  --selections '[{"app_name":"google-sheets","app_version":2,"endpoint_names":["getValues","updateValues"]}]' \
  --idempotency-key make-credential-request-1 \
  --json
```

When the response includes an `authorization_url`, open it privately. Save the `request_id` to check status later with `integration_credential_request_status` or the CLI.

```sh theme={null}
ohmyhost connection credential-request-status \
  --organization ORGANIZATION_ULID \
  --grant GRANT_ULID \
  --request REQUEST_HASH \
  --json
```

When Make reports `provider_status: authorized`, use discovery again to find the connection before importing it into a project. If the result is `reconnect_required`, renew the workspace Make grant to authorize its Credential Request permissions.

Reuse the same idempotency key and selections for the same request under the workspace grant. Changing the selections or team with that key conflicts. If the result is `uncertain`, check the original request in Make before creating another one.

## Import into a project

Ask for an import when you want to save a connection reference in a particular app. For example, “Import that connection into the dev environment of my support app.” The agent can reuse the project and environment from your request or chat context and ask if the destination is unclear. You can import the same connection into another authorized project in your workspace using the same Make grant.

Use `integration_connection_import` in chat or the following CLI command with IDs from discovery and project context.

```sh theme={null}
ohmyhost connection import \
  --organization ORGANIZATION_ULID \
  --grant GRANT_ULID \
  --project PROJECT_ULID \
  --environment ENVIRONMENT_ULID \
  --provider-organization MAKE_ORGANIZATION_ID \
  --team TEAM_ID \
  --connection CONNECTION_ID \
  --idempotency-key make-import-1 \
  --profile-name PROFILE_NAME --json
```

## Run a Make action

An older Make grant continues to support discovery. Renew your Make authorization to grant the additional permissions for execution.

After importing a connection into the intended project and environment, a workspace owner can bind a published Make Endpoint using `POST /v1/organizations/{organization_id}/connections/action-bindings`. The selected connection must match the Endpoint's requirements, including the app account permissions. Make runs the action confidentially. The binding flow is the same for each Make app. Use the [Make Endpoints SDK](https://developers.make.com/make-sdk/make-endpoints-sdk) definitions to discover the exact app, version, Endpoint name and input schema. Then bind with `createMakeActionBinding` in the generated ohmyhost SDK or the REST call below, and make the server-side call with the SDK's `runMakeAction` or REST. Use the CLI or MCP for discovery and import, and the SDK or REST for action binding and execution.

For example, bind a published Endpoint using an owner API token, IDs from the imported connection and its exact app, version and Endpoint names:

```sh theme={null}
umask 077
printf 'header = "Authorization: Bearer %s"\n' "$OWNER_API_TOKEN" | \
  curl --config - --request POST "https://app.ohmyho.st/v1/organizations/$ORGANIZATION_ID/connections/action-bindings" \
  --output make-action-binding.private.json \
  --header "Idempotency-Key: bind-action-1" \
  --header "Content-Type: application/json" \
  --data '{"project_id":"PROJECT_ULID","environment_id":"ENVIRONMENT_ULID","import_id":"IMPORT_ULID","action":{"kind":"endpoint","app_name":"APP_NAME","app_version":1,"endpoint_name":"ENDPOINT_NAME"}}'
```

Use the Development platform origin for a Development platform workspace. The private response file contains an `execution_key`. Save it as a [runtime secret](https://docs.ohmyho.st/secrets.md) for the app server and remove the temporary response file after setup. Keep that key out of browser code and messages. The server sends that key as its bearer, an idempotency key for the intended action and an input object. It does not receive or send Make OAuth credentials.

For example, this server-side JavaScript sends input to the bound Endpoint. Supply a stable, unique `intentKey` for each logical invocation, provide input matching the Endpoint definition, and set `MAKE_ACTION_KEY` as a runtime secret, available here on the server environment object `env`.

```js theme={null}
const response = await fetch("https://app.ohmyho.st/v1/make/actions/run", {
  method: "POST",
  redirect: "manual",
  headers: {
    Authorization: `Bearer ${env.MAKE_ACTION_KEY}`,
    "Content-Type": "application/json",
    "Idempotency-Key": intentKey,
  },
  body: JSON.stringify({ input: endpointInput }),
});
if (response.status >= 300 && response.status < 400) {
  throw new Error("Unexpected redirect from the Make action API");
}
const result = await response.json();
```

Use the Development platform origin when appropriate. The request rejects redirects so the action key stays on that origin. Check `response.ok` and `result.state` before using a result. Reusing the same key for the same intent preserves the existing execution outcome. A `502` with `uncertain` needs investigation before another invocation. [Cloudflare Workers request options](https://developers.cloudflare.com/workers/runtime-apis/request/)

When a direct Endpoint definitely did not dispatch, an application can opt into a Make API Shell fallback, including for file cases. Use the `make-api-shell-connection-workflow` skill to set up the shell. The owner binds an active on-demand, three-module app-specific API Shell configured with the exact imported Make connection. Its action identifies `scenario_id`, `method` and an origin-relative `path_prefix`. Runtime input uses the shell fields `path`, `method`, `header`, `qs` and `body` within that pinned authority. Do not fall back after an uncertain write outcome. Arbitrary scenarios, routes and URLs are not supported.

Download the existing Make skill, [Make API Shell + Connection Workflow](https://raw.githubusercontent.com/sebmer-com/make-skills/2b053dbd2d4892e17a485e9999a2dd9745443da7/dist/make-api-shell-connection-workflow.zip) (pinned fork [source](https://github.com/sebmer-com/make-skills/tree/2b053dbd2d4892e17a485e9999a2dd9745443da7/skills/make-api-shell-connection-workflow)). If you are helping a user in chat, share this ZIP link so they can install the skill in a compatible agent or upload it where skill ZIPs are supported.

Add the exact applicable platform origin, `https://app.ohmyho.st` or `https://dev.app.ohmyho.st`, to the application's `runtime.egress.allow` in its manifest and deploy the change. Use the API for binding and execution. Your agent can continue to discover and import connections through MCP.

## Older clients

Version 0.1.62 clients pass project and environment together when beginning a connection or discovering its catalog. Those paired parameters remain supported for the earlier project-scoped flow. Use a current client for workspace connection, discovery and import; a project-scoped connection does not automatically become a workspace grant.

## Disconnect

Use `integration_connection_disconnect`, or the CLI's `connection disconnect` command with its required confirmation. Disconnect immediately blocks local use and requests upstream revocation. It does not delete the third-party connections stored in your Make team. If revocation is still pending, retain that reported state and follow it rather than treating it as confirmed.

```sh theme={null}
ohmyhost connection disconnect \
  --organization ORGANIZATION_ULID \
  --grant GRANT_ULID \
  --idempotency-key make-disconnect-1 \
  --yes --profile-name PROFILE_NAME --json
```

A refused or unavailable connection needs its reported account, permission or provider issue resolved. Repeating consent or changing client transport does not expand your access. [Sign-in and account selection](https://docs.ohmyho.st/login-tokens.md) explains saved logins and current workspace rights.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.