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

> ## Agent Instructions
> AutoGrowth runs social accounts on real phones. Everything a page describes happens on a physical device in the customer's own fleet, never through a social platform's API.
> The Companion is a macOS desktop app that runs on the customer's own Mac and manages the phones over USB — iPhones through WebDriverAgent, GrapheneOS phones through ADB and scrcpy. Nothing runs while the Companion is closed.
> The Companion builds, signs and installs WebDriverAgent on each iPhone itself. Never tell a customer to sign WebDriverAgent by hand in Xcode; Xcode is a prerequisite the Companion drives, not a step the customer performs.
> Autogrowth MAX is a one-time, invite-only lifetime license bought from the organization's credit balance, not a subscription tier. It is required to run any automation, workflow or Incubator program. Without a price set for that organization, the purchase is refused.
> An automation is one of AutoGrowth's built-in definitions; a script is a graph the customer builds in the Script Builder. The Script Builder is locked platform-wide, so never present building a script as something a customer can do today.
> An API key is a bare 64-character hex string with no prefix. It is shown once, at creation, is sent as `Authorization: Bearer <key>`, and can never be read back.
> An API key sees only the key owner's own accounts, content, collections, prompts, scripts and executions. Devices and tags are organization-scoped, and a non-owner sees only the devices assigned to them or carrying one of their tags. The automation catalog is global.
> There is no pagination. List endpoints return the whole set; the only limiting parameter anywhere is `limit` on `GET /v1/executions`, which defaults to 50 and has no offset to page with.
> Remote control and the live screen are dashboard-only, over WebSocket and MJPEG. Neither is part of the public API.
> The MCP server is hosted at https://mcp.autogrowth.farm and authenticates with OAuth. It is not an npm package and there is nothing to install locally. Its tools inherit exactly the scope of the API key behind them.
> Android support is partial and GrapheneOS-only: those phones appear in the fleet and can be watched and remote-controlled, but they cannot run scripts or automations.
> Never document Hi Katie or any persona feature. When a page and the code disagree, the code wins — check a claim against the source before repeating it.

# API overview

> What the public API reaches, what it deliberately does not, and how a key's view differs from the dashboard's.

The AutoGrowth API is how you schedule work on your fleet from your own code. It
reads the same rows the dashboard reads — phones, accounts, automations, content —
and writes the same executions the dashboard writes.

```
https://api.autogrowth.farm/v1
```

Every endpoint takes a bearer key and returns JSON. Full field-by-field detail is
in the [API Reference](/api-reference); this tab is the shape around it.

## What it reaches

| Resource        | You can                                                                                    |
| --------------- | ------------------------------------------------------------------------------------------ |
| **Devices**     | List the phones you can reach, and assign tags or teammates to one                         |
| **Accounts**    | List, read, pause and resume your social accounts, and read their scraped follower history |
| **Automations** | Read the built-in catalog and each automation's inputs                                     |
| **Scripts**     | Read your scripts, including their node graph                                              |
| **Executions**  | Schedule runs one at a time or 100 at a time, list them, cancel and delete them            |
| **Content**     | Upload media, list it, star it, delete it, and check storage usage                         |
| **Collections** | Create, update and delete collections, and move content in and out                         |
| **Prompts**     | Full create, read, update and delete                                                       |
| **Tags**        | List the organization's tags                                                               |
| **Stats**       | The dashboard's aggregate counters                                                         |

## What it does not reach

* **The live screen and remote control.** Both are dashboard-only, over WebSocket
  and MJPEG. There is no API for either.
* **The Companion.** Nothing in the API installs, starts or configures the desktop
  app, and nothing runs while it is closed.
* **Script authoring.** Scripts are read-only here, and the Script Builder is locked
  platform-wide.
* **Billing.** Buying slots, credits or Autogrowth MAX happens in the dashboard.

## Quickstart

<Steps>
  <Step title="Create a key" icon="key">
    In the dashboard, open **Settings → Developer API** and create a key. It is
    shown once — copy it into your secret manager immediately. You need the
    **Manage API keys** permission to see that screen. Details in
    [Authentication](/api/authentication).
  </Step>

  <Step title="List your phones" icon="mobile">
    <CodeGroup>
      ```bash cURL theme={"dark"}
      curl https://api.autogrowth.farm/v1/devices \
        -H 'Authorization: Bearer a1b2...replace-with-your-key'
      ```

      ```javascript Node.js theme={"dark"}
      const res = await fetch('https://api.autogrowth.farm/v1/devices', {
      	headers: { Authorization: `Bearer ${process.env.AUTOGROWTH_API_KEY}` },
      });
      const { devices } = await res.json();
      for (const device of devices) {
      	console.log(device.id, device.name, device.online, device.slotState);
      }
      ```

      ```python Python theme={"dark"}
      import os, requests

      res = requests.get(
      	"https://api.autogrowth.farm/v1/devices",
      	headers={"Authorization": f"Bearer {os.environ['AUTOGROWTH_API_KEY']}"},
      )
      for device in res.json()["devices"]:
      	print(device["id"], device["name"], device["online"], device["slotState"])
      ```
    </CodeGroup>

    Note the `id` of a phone whose `slotState` is `active`. A phone with an
    expired slot cannot be scheduled on.
  </Step>

  <Step title="Schedule a run" icon="calendar">
    Automation IDs come from
    [`GET /automations`](/api-reference/automations/list-automations), which also
    returns each automation's `inputs`. Keys in `inputValues` are those inputs'
    `id` fields.

    <CodeGroup>
      ```bash cURL theme={"dark"}
      curl -X POST https://api.autogrowth.farm/v1/executions \
        -H 'Authorization: Bearer a1b2...replace-with-your-key' \
        -H 'Content-Type: application/json' \
        -d '{
          "automationId": "warmup-instagram",
          "deviceId": "0198f8a0-1111-7aaa-8ccc-3e5d7c9b1a24",
          "scheduledAt": "2026-09-01T14:00:00Z",
          "inputValues": { "account": "yourhandle", "duration": "30" }
        }'
      ```

      ```javascript Node.js theme={"dark"}
      const res = await fetch('https://api.autogrowth.farm/v1/executions', {
      	method: 'POST',
      	headers: {
      		Authorization: `Bearer ${process.env.AUTOGROWTH_API_KEY}`,
      		'Content-Type': 'application/json',
      	},
      	body: JSON.stringify({
      		automationId: 'warmup-instagram',
      		deviceId: deviceId,
      		scheduledAt: '2026-09-01T14:00:00Z',
      		inputValues: { account: 'yourhandle', duration: '30' },
      	}),
      });
      if (!res.ok) throw new Error((await res.json()).error);
      const { execution, conflicts } = await res.json();
      ```

      ```python Python theme={"dark"}
      import os, requests

      res = requests.post(
      	"https://api.autogrowth.farm/v1/executions",
      	headers={
      		"Authorization": f"Bearer {os.environ['AUTOGROWTH_API_KEY']}",
      		"Content-Type": "application/json",
      	},
      	json={
      		"automationId": "warmup-instagram",
      		"deviceId": device_id,
      		"scheduledAt": "2026-09-01T14:00:00Z",
      		"inputValues": {"account": "yourhandle", "duration": "30"},
      	},
      )
      res.raise_for_status()
      execution = res.json()["execution"]
      ```
    </CodeGroup>

    A `201` means the run is queued, not that it has happened. Poll
    [`GET /executions`](/api-reference/executions/list-executions) for its
    `status`, or read it back by ID.

    The response also carries `conflicts`: pending runs on the same phone whose
    window overlaps this one. It is information, not a rejection — the phone runs
    one execution at a time and queues the rest.
  </Step>
</Steps>

<Warning>
  Running an automation requires **Autogrowth MAX**. Without it, `POST
    	/executions` answers `403` with the code `MAX_REQUIRED`. Listing the catalog
  works either way.
</Warning>

## Before you build

<CardGroup cols={2}>
  <Card title="Authentication" icon="key" href="/api/authentication">
    Key format, the bearer header, and the scoping rule that surprises everyone.
  </Card>

  <Card title="Conventions" icon="ruler" href="/api/conventions">
    IDs, timestamps, dropped nulls, expanded references, no pagination.
  </Card>

  <Card title="Errors" icon="triangle-exclamation" href="/api/errors">
    The error envelope, the codes, and what to do about each.
  </Card>

  <Card title="API Reference" icon="terminal" href="/api-reference">
    Every endpoint, generated from the spec.
  </Card>
</CardGroup>
