MCP server

Overview#

trackagoat runs a hosted Model Context Protocol server. Connect Claude.ai or Claude Desktop by signing in with your trackagoat account, or point any MCP client at it with an API key. Your agent can then check a program's health, browse projects, creators, videos, campaigns, goals, conversions and payouts, pull analytics, and (with write access) do what the REST API does: add, change and remove creators, accounts, videos, campaigns, goals and content groups, record conversions, set up payout structures, assign creators to them, and record or void payments. It can also read and write the Markdown documents on every record and export any CSV the app exports.

Every tool is a thin adapter over one /api/v2 endpoint, so MCP and REST return the same data and enforce the same permissions and limits.

A connection always acts as one member of the organization: the person who signed in, or the member an API key acts as. Everything the agent does is attributed to them, and it can never do more than they can do in the app. When the agent connects, the server sends that person's personalization document along with its instructions, so the agent starts out knowing who it is helping and how they want help.

New to trackagoat? Set up with a coding agent also covers sign-up and plan limits.

Claude.ai and Claude Desktop (custom connector)#

Claude connects natively: no API key, no config file, no mcp-remote. You sign in with your trackagoat account and choose what Claude may do.

1. 1

   Add the connector

   In Claude, open Settings → Connectors (on claude.ai: Customize → Connectors) and choose Add custom connector. Enter:

   • Name: trackagoat
   • Remote MCP server URL: https://www.trackagoat.com/api/mcp

   Leave the advanced OAuth client ID and secret fields empty. On Team and Enterprise plans, an Owner adds the connector once for the organization and each person then connects their own account.

2. 2

   Sign in and approve

   Click Connect. A trackagoat window opens. Sign in if you aren't already, then:

   • pick the organization Claude may see (one per connection), and
   • choose View data (always on) and, optionally, Make changes for the write tools.

   Click Allow access. You're returned to Claude and the trackagoat tools appear in the connector list.

3. 3

   Use it

   Enable the connector in a chat (the + / tools menu) and ask about your creators. Claude Desktop, Claude mobile and claude.ai share the same connection.

Good to know:

• Claude acts as you, limited to what you allowed and to your current role. If your role changes or you leave the organization, its access changes or stops at once.
• If you allowed only View data and later ask Claude to change something, Claude asks you to reconnect and approve Make changes.
• To use a second organization, add the connector again and pick the other organization.
• To disconnect, remove the connector in Claude, or go to Settings → Connected Apps in trackagoat. Org admins can also disconnect any member's app under Org settings → API keys → Connected apps.
• Connected apps don't use up your plan's API key limit, but every tool call counts toward the org's daily API requests, like a key. Every plan can connect apps; Free allows 200 requests a day.

The same sign-in works for other MCP clients that support OAuth, including Claude Code, Codex, Cursor and VS Code: give them the URL above and they discover everything else from it. See Connect a client.

Get an API key#

Use an API key for scripts, and for clients that can't sign in with OAuth. In trackagoat, go to Org settings → API keys → + New API key. Name it after the client (e.g. Claude Code laptop) and choose scopes:

• read: required for every read tool.
• write: required for the write tools. Leave it off if the agent should only read.

Copy the key: it's shown once. See Authentication and API keys for expiry and revocation. A key acts on behalf of one member: the admin who created it, or the member picked under Acts as. It can never do more than that member can in the app, and it stops working if they leave the org. A key made for someone else also stops working if the admin who created it leaves, is changed to member or is suspended (see Who a key acts as).

Connect a client#

Each client below can sign in (no key) or send an API key. Keep keys in an environment variable such as TRACKAGOAT_API_KEY, never in a committed file.

Claude Code#

Sign in:

claude mcp add --transport http trackagoat https://www.trackagoat.com/api/mcp

Then run /mcp in Claude Code, select trackagoat and sign in. With an API key instead:

claude mcp add --transport http trackagoat https://www.trackagoat.com/api/mcp \
  --header "Authorization: Bearer $TRACKAGOAT_API_KEY"

Add --scope user to make it available in every project. To share the setup with your team without committing a key, put this in the repo's .mcp.json and have each person export TRACKAGOAT_API_KEY:

{
  "mcpServers": {
    "trackagoat": {
      "type": "http",
      "url": "https://www.trackagoat.com/api/mcp",
      "headers": { "Authorization": "Bearer ${TRACKAGOAT_API_KEY}" }
    }
  }
}

Run /mcp in Claude Code to confirm trackagoat shows as connected.

Codex CLI#

Sign in:

codex mcp add trackagoat --url https://www.trackagoat.com/api/mcp
codex mcp login trackagoat

With an API key instead, Codex reads the variable each time it starts:

codex mcp add trackagoat --url https://www.trackagoat.com/api/mcp \
  --bearer-token-env-var TRACKAGOAT_API_KEY

Cursor#

Add to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (one project). To sign in, leave out headers and sign in from Cursor's MCP settings. With an API key:

{
  "mcpServers": {
    "trackagoat": {
      "url": "https://www.trackagoat.com/api/mcp",
      "headers": { "Authorization": "Bearer ${env:TRACKAGOAT_API_KEY}" }
    }
  }
}

VS Code#

Add to .vscode/mcp.json, then start the server. Without headers (and inputs), VS Code asks you to sign in. With an API key, VS Code prompts for it once and stores it securely:

{
  "inputs": [
    { "type": "promptString", "id": "trackagoat-key", "description": "trackagoat API key", "password": true }
  ],
  "servers": {
    "trackagoat": {
      "type": "http",
      "url": "https://www.trackagoat.com/api/mcp",
      "headers": { "Authorization": "Bearer ${input:trackagoat-key}" }
    }
  }
}

Stdio-only clients#

For clients that only launch local (stdio) servers, bridge with mcp-remote (requires Node.js 18+). For example, in Claude Desktop's claude_desktop_config.json (Settings → Developer → Edit config), though the custom connector is simpler there:

{
  "mcpServers": {
    "trackagoat": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://www.trackagoat.com/api/mcp",
        "--header",
        "Authorization:${TRACKAGOAT_AUTH}"
      ],
      "env": { "TRACKAGOAT_AUTH": "Bearer tga_<key>" }
    }
  }
}

Keep Authorization:${TRACKAGOAT_AUTH} without spaces: some clients split arguments on spaces, so the Bearer prefix goes in the env var.

Other clients#

Any client that supports Streamable HTTP works: either let it sign in with OAuth (it discovers the authorization server from the 401 response, per the MCP authorization spec), or send Authorization: Bearer tga_<key> on every request.

Tools#

Each tool's description and input schema are served to your client, so the agent sees parameter docs directly. Schemas are strict: a parameter a tool doesn't have (say range on get_analytics, which takes from and to) is rejected with unknown_parameter instead of being silently ignored. Tool results are compact JSON: image URLs are dropped, and list tools preview long readme notes (call the matching get_* tool for the full text).

Read tools#

All require the read scope, except get_changelog, which works on any connection. Tools marked Org admin only also need the connection to act as an org admin, like the matching page in the app; for anyone else they return insufficient_role. Each tool's description says the same.

Projects, creators, accounts and videos

Comments (paid plans; 403 plan_feature_unavailable on Free)

Program health, goals and campaigns

Analytics

The heatmap, consistency, over-posting, view-distribution and campaign-trend tools default to the last 30 days when from and to are left out.

Conversions

Payouts

Notes and documents

Exports

What's new in trackagoat

The data model is also available as the MCP resource trackagoat://schema.

Write tools#

All require the write scope (Make changes when connecting with sign-in). A key without it gets an insufficient_scope error and nothing is changed; a signed-in client is asked to reconnect with Make changes. Tools marked can't be undone are annotated destructiveHint: true, so most clients ask before running them. Tools marked Org admin only need the connection to act as an org admin (insufficient_role otherwise).

Creators and accounts

Videos

Campaigns, goals, content groups and share pages

Comment settings

Conversions

Payouts

Receipts and method icons

To attach a receipt, the agent generates a UUID as payment_id, uploads the file under it (upload_receipt, or get_receipt_upload_url and a PUT of the raw bytes with the same Content-Type), then calls record_payout_payment with that payment_id and attachment_path set to the returned path. A receipt can only be attached when the payment is recorded, as in the app. Allowed receipt types: PNG, JPEG, WebP, PDF, CSV, Word and Excel. Inline uploads are checked: the file's contents must match content_type.

Tools that create something or act in bulk accept an optional idempotency_key (it is sent as the REST Idempotency-Key header). Have the agent pass a fresh UUID per logical write: if a call times out and is retried with the same key and arguments within 24 hours, you get the original result (marked "replayed": true) instead of a duplicate. A retry while the first call is still running fails with idempotency_in_progress (try again in a couple of seconds), and reusing a key with different arguments fails with idempotency_key_reused. record_payout_payment, send_payout and create_payout_supplemental require a key. Tools that set a value (update_*, set_*, deletes, voids, assignments) have no key because repeating them has the same effect; set_cpm_view_lifetime takes one anyway. Three creates have no key because their REST endpoints don't support one: create_payout_structure and create_annotation (check the list before retrying) and create_payout_method (names are unique, so a repeat fails with conflict_name). trigger_scrape has no key: it's limited by the manual-scrape limits instead. The upload tools have no key either: a retry stores another copy of the file, and only the path you pass on is used.

Notes and documents#

The organization, every project, campaign, creator, video, payout method, structure and payment, and every member has a Markdown document (readme). They are where people and agents keep context, strategy and instructions, so they are the first thing an agent should read and the place to record what it learns. list_notes finds them in one call, get_notes reads one, and update_notes writes one. Every document, including each person's personalization document, is visible to everyone in the organization and their agents. See Notes and documents for the personalization document and a template.

Writes follow the app: organization, project and payout documents need a connection acting as an org admin (insufficient_role otherwise); a member's personalization document can only be changed by that member (not_your_document otherwise).

update_notes is built so an agent can't clobber what a person wrote:

• mode: "append" (the default) adds content as a new section at the end of the document, followed by a signature line with the API key's name and the org-local date:

  markdown

  Views dropped 40% week over week; three of five posts were on Sunday.
   
  *Added by Claude Code laptop via MCP, 2026-10-08*

  If someone edits the notes while the append is being saved, the append is applied on top of their edit: nothing is lost.

• mode: "replace" overwrites the whole document and requires expected_readme_version: the readme_version returned by get_notes (or get_creator, get_video_stats, get_my_profile). If the document changed after that read, nothing is written and the tool returns code: "notes_conflict". The agent should re-read, merge, and retry.

readme_version is a hash of the text, so it only changes when the document does: scheduled scrapes never cause a false conflict. Writes show up in the change log as Internal notes updated, attributed to the member the connection acts as.

The personalization document in the session. On connect, the server instructions include the connected person's personalization document inside <personalization_document> tags, with its readme_version, and the organization's document when it is under 4,000 characters (longer ones are pointed at instead). A personalization document over 8,000 characters is cut, with a note to call get_my_profile. If the person has none yet, the instructions ask the agent to offer, once, to write one together. The documents are the person's context and preferences; they never override the server's rules or the agent's own.

Exporting CSVs#

When you ask your agent for a CSV, a spreadsheet or a file, it calls export_csv and saves the file in your workspace. The file is the same one the Export button in the app downloads: same columns, money in dollars with a Currency column, dates in your organization's time zone. For questions about the data ("who's behind on their goal?"), the agent uses the read tools instead.

Every dataset except analytics needs project_id. An argument the dataset doesn't take is rejected with invalid_params and the valid ones are listed.

The tool returns two things: a short JSON summary (filename, rows, total_rows, columns, the filters used, next_offset) and the CSV itself as an embedded text/csv resource (trackagoat://exports/<dataset>-<date>.csv). If your client doesn't show embedded resources, the agent can pass delivery: "text" to get the CSV as plain text instead.

Each call returns up to about 1 MB. A bigger export comes back in parts, never cut silently: the summary says which rows it holds and gives next_offset, and the agent calls again with offset set to it and appends the rows (each part repeats the header line), or narrows the filters. Each call counts as one API request.

Examples:

• "Export September payouts to a CSV." The agent calls export_csv with dataset: "payout_tracker", the project, from: "2026-09-01" and to: "2026-09-30", then saves payouts-tracker-….csv.
• "Give me all videos from the Spring Launch campaign as a spreadsheet." The agent finds the campaign with list_campaigns, then calls export_csv with dataset: "videos" and its campaign_id.

What the MCP server doesn't do#

Everything an organization's API key can do through /api/v2 can also be done over MCP, except the following, which are left out on purpose:

Limits#

• Each tool call counts as one API request toward your org's daily max_api_requests_per_day limit and the per-key limit of 60 requests per minute, the same as a REST call. Connecting and listing tools are free. A signed-in connection is limited like one key.
• get_changelog is the exception: it reads public content, so it never counts toward the daily limit. It has its own limit of 60 calls per minute per key or connection.
• Protocol traffic (connect, list tools, ping) is capped at 120 requests per minute per key or connection.
• trigger_scrape also counts against your plan's daily manual-scrape limit.
• add_creator, add_creators, add_account and add_video_by_url count against your plan's account and video limits; create_campaign, create_conversion_event, create_payout_structure and create_payout_method count against their plan limits.
• set_cpm_view_lifetime counts as two API requests (it reads the structure, then saves it).
• Analytics ranges can't start before your plan's data-retention window.

When a limit is hit the tool returns an error with code: "rate_limit_exceeded" and retry_after_seconds. See Limits & plan tiers.

Errors#

Tool failures come back as MCP tool errors (isError: true) whose text is JSON:

{
  "error": "add_creator requires the 'write' scope. Granted: [read]",
  "code": "insufficient_scope",
  "status": 403,
  "hint": "This API key lacks the 'write' scope. An org admin can create a key with that scope in Org settings → API keys."
}

code and status match the REST error codes; every error has a code, so an agent can branch on it instead of parsing error. When the route returns extra context, it's in details. Codes you'll see most:

{
  "error": "Unknown parameter 'range'. Valid parameters: entity, entity_id, entity_ids, metric, granularity, bucket_days, mode, from, to, compare, breakdown, top_n, base_metric.",
  "code": "unknown_parameter",
  "status": 400,
  "hint": "get_analytics accepts only the parameters listed above; unknown ones are rejected rather than ignored. Remove or rename them and call again.",
  "details": { "unknown_parameters": ["range"], "valid_parameters": ["entity", "entity_id", "…"] }
}

An invalid, expired or revoked key is rejected before any tool runs, with HTTP 401; your client will show the server as failing to connect. So is a key whose member left the org (key_member_removed), or a key made for someone else whose creator left, was changed to member or was suspended (key_creator_removed, key_creator_not_admin, key_creator_banned). Org settings → API keys shows why a key stopped working. A signed-in client gets the same 401 with a WWW-Authenticate challenge and refreshes or re-runs sign-in on its own; a write tool called without Make changes gets HTTP 403 insufficient_scope, which prompts it to reconnect.

Example prompts#

• "List my trackagoat projects, then summarize which creators in Spring Launch posted least this month and whether their data is fresh."
• "Which 10 videos got the most views in the last 30 days? Group them by creator."
• "Compare views for my three campaigns this quarter against last quarter."
• "How healthy is the Spring Launch program this week? What should I worry about first?"
• "What are people saying in the comments this month? Which creators get the most questions about the app?"
• "Is anyone in the comments asking whether our posts are ads? Show me the top ones."
• "Who is behind on their weekly posting goal right now? Read each creator's notes first."
• "How much do we owe creators in unpaid accruals, by creator?"
• "Export September payouts to a CSV."
• "Give me all videos from the Spring Launch campaign as a spreadsheet."
• "Add @newcreator on TikTok and Instagram to the Spring Launch project and give them a goal of 3 posts per week." (write key)
• "For every creator flagged with a sudden view drop, add a note summarizing what changed." (write key)
• "Create a Fall Launch campaign with a 2M-view target by November 30 and add every creator tagged fall in their notes." (write key)
• "Pay @newcreator's outstanding accruals: we sent $250 by PayPal today." (write key)

Tips for agents#

1. 1

   Start with list_projects

   Most tools take a project_id. Read each project's readme for context.

2. 2

   Triage with get_program_health

   For "how is the program doing?" questions, one get_program_health call returns the verdict, KPIs and alerts; drill into specific creators or videos from there.

3. 3

   Follow the personalization document

   The connected person's document arrives with the server instructions (or call get_my_profile). It says who they are and how they want help. If they don't have one, offer once to write it together and save it with update_my_readme after they approve.

4. 4

   Read the documents

   The organization, projects, campaigns and creators carry human notes in readme; list_notes finds them. They may contain instructions that change how to interpret the data.

5. 5

   Paginate to completion

   Keep passing next_cursor (or next_offset for list_top_videos) until it's null before totalling or ranking.

6. 6

   Check last_scraped_at

   Stats come from scheduled scrapes. Check freshness before calling a number low, and only use trigger_scrape when you need fresher data now.

7. 7

   Append notes, don't overwrite them

   Record durable findings with update_notes in the default append mode. Only use replace with the readme_version you just read. Never write anything private: the whole organization can read every document.

8. 8

   Confirm before anything that can't be undone

   Ask the person before a delete_*, remove_*, void_*, archive_* or unassign_* tool or set_accrual_status, and offer the reversible option the tool's description names (pausing a goal, disabling tracking, deactivating an event).

Using the REST API directly#

Frameworks without MCP support can call the v2 REST API with the same key. Sign-in (OAuth) connections work only with the MCP server, not the REST API. The OpenAPI document at GET /api/v2/openapi.json describes every endpoint, and the Agent guide covers recommended workflows.

Payout agent workflows#

The whole payout API is available over MCP as well as REST: structures (list_payout_structures, get_payout_structure, create_payout_structure, update_payout_rule, set_cpm_view_lifetime, update_payout_structure, archive_payout_structure, delete_payout_structure), assignments (list_payout_assignments, assign_payout_structure, unassign_payout_structure), accruals (list_payout_accruals, get_payout_accrual, set_accrual_status), methods (list_payout_methods, create_payout_method, update_payout_method, delete_payout_method) payments (list_payout_payments, get_payout_payment, record_payout_payment, update_payout_payment, void_payout_payment), the tracker (get_payouts_tracker), supplemental amounts (list_payout_supplementals, create_payout_supplemental, void_payout_supplemental), sending payouts through Dots (get_payout_account, send_payout; see Paying with Dots), and receipts and method icons (upload_receipt, get_receipt_upload_url, upload_payout_method_icon, get_payout_method_icon_upload_url). The workflows below show the REST calls; each step names the MCP tool that does the same. Reads need the read scope; writes (recording payments, voiding, assigning structures) need the write scope: a read-only key gets 403 insufficient_scope on any mutation. See the Payouts API reference for full endpoint documentation.

Workflow 1: Weekly payout review#

Goal: find all creators with outstanding accruals, summarize total owed, and surface any that have been outstanding more than 30 days.

Over MCP: list_projects, then list_payout_accruals with status: "earned".

1. 1

   Discover the project

   bash

   curl -s -H "Authorization: Bearer $TGA_KEY" \
     "https://www.trackagoat.com/api/v2/projects" | jq '.data[0].id'

   Store the project ID as $PROJECT_ID.

2. 2

   List outstanding accruals

   bash

   curl -s -H "Authorization: Bearer $TGA_KEY" \
     "https://www.trackagoat.com/api/v2/payout-accruals?project_id=$PROJECT_ID&status=earned" \
     | jq '{total: (.data | length), creators: [.data[] | .creator_id] | unique | length}'

   Paginate using meta.nextCursor until meta.hasMore is false.

3. 3

   Flag stale accruals

   Filter data[].period_end_at older than 30 days ago. Report creator handle + amount + how many days outstanding.

   Expected response shape:

   JSON

   {
     "data": [{
       "id": "uuid",
       "creator_id": "uuid",
       "structure_id": "uuid",
       "amount_cents": 5000,
       "currency": "USD",
       "status": "earned",
       "period_start_at": "2026-04-07T00:00:00Z",
       "period_end_at": "2026-04-13T23:59:59Z"
     }],
     "meta": { "hasMore": false, "nextCursor": null }
   }

Workflow 2: Audit unpaid creators across an org#

Goal: identify which creators have earned money but received zero payments, broken down by project.

Over MCP: list_projects, list_payout_structures, list_payout_accruals and list_payout_payments.

1. 1

   List all projects

   bash

   curl -s -H "Authorization: Bearer $TGA_KEY" \
     "https://www.trackagoat.com/api/v2/projects" | jq '[.data[] | {id, name}]'

2. 2

   For each project, fetch payout structures

   bash

   curl -s -H "Authorization: Bearer $TGA_KEY" \
     "https://www.trackagoat.com/api/v2/payout-structures?project_id=$PROJECT_ID&is_active=true"

3. 3

   Fetch earned accruals per project

   bash

   curl -s -H "Authorization: Bearer $TGA_KEY" \
     "https://www.trackagoat.com/api/v2/payout-accruals?project_id=$PROJECT_ID&status=earned"

4. 4

   Fetch all payments

   bash

   curl -s -H "Authorization: Bearer $TGA_KEY" \
     "https://www.trackagoat.com/api/v2/payout-payments?project_id=$PROJECT_ID"

5. 5

   Compute the gap

   Group accruals by creator_id. For each creator, sum amount_cents of earned accruals. Compare against total_amount_cents of paid payments. Report the delta.

Workflow 3: Record a payment for a creator via Venmo#

Goal: settle outstanding accruals for a specific creator and record the payment against the Venmo method.

Over MCP: list_creators with search, list_payout_accruals, list_payout_methods, optionally upload_receipt, then record_payout_payment with a fresh idempotency_key (the tool requires one).

1. 1

   Find the creator

   bash

   curl -s -H "Authorization: Bearer $TGA_KEY" \
     "https://www.trackagoat.com/api/v2/creators?project_id=$PROJECT_ID&search=creatorhandle" \
     | jq '.data[0].id'

2. 2

   List outstanding accruals for this creator

   bash

   curl -s -H "Authorization: Bearer $TGA_KEY" \
     "https://www.trackagoat.com/api/v2/payout-accruals?project_id=$PROJECT_ID&status=earned" \
     | jq '[.data[] | select(.creator_id == $CREATOR_ID)]'

   Sum the amount_cents values to get total_amount_cents.

3. 3

   Find the Venmo method ID

   bash

   curl -s -H "Authorization: Bearer $TGA_KEY" \
     "https://www.trackagoat.com/api/v2/payout-methods" \
     | jq '.data[] | select(.name == "Venmo") | .id'

4. 4

   Record the payment

   bash

   curl -s -X POST -H "Authorization: Bearer $TGA_KEY" \
     -H "Content-Type: application/json" \
     -H "Idempotency-Key: $(uuidgen)" \
     "https://www.trackagoat.com/api/v2/payout-payments" \
     -d '{
       "creator_id": "CREATOR_UUID",
       "method_id": "VENMO_METHOD_UUID",
       "total_amount_cents": 5000,
       "currency": "USD",
       "accrual_ids": ["ACCRUAL_UUID_1", "ACCRUAL_UUID_2"],
       "note": "Recorded by automated weekly review agent",
       "paid_at": "2026-05-07T15:00:00Z"
     }'

   Expected 201 response:

   JSON

   {
     "data": {
       "id": "payment-uuid",
       "creator_id": "...",
       "total_amount_cents": 5000,
       "status": "paid",
       "paid_at": "2026-05-07T15:00:00Z"
     }
   }

Workflow 4: Set up a new creator with a goal-based payout structure#

Goal: assign an existing payout structure to a newly-tracked creator and confirm the assignment is active.

Over MCP: list_payout_structures, assign_payout_structure, then list_payout_assignments.

1. 1

   Confirm the structure exists and is active

   bash

   curl -s -H "Authorization: Bearer $TGA_KEY" \
     "https://www.trackagoat.com/api/v2/payout-structures?project_id=$PROJECT_ID&is_active=true" \
     | jq '[.data[] | select(.criteria_type == "goals") | {id, name, period, amount_cents}]'

   Pick the structure ID you want to assign.

2. 2

   Assign the creator

   bash

   curl -s -X POST -H "Authorization: Bearer $TGA_KEY" \
     -H "Content-Type: application/json" \
     "https://www.trackagoat.com/api/v2/payout-structures/$STRUCTURE_ID/assignments" \
     -d '{"creator_ids": ["CREATOR_UUID"]}'

   Expected 201 response:

   JSON

   {
     "data": {
       "assigned": 1,
       "already_assigned": 0,
       "not_in_project": 0,
       "results": [{ "creator_id": "...", "status": "assigned", "assignment_id": "..." }]
     }
   }

3. 3

   Verify the assignment is active

   bash

   curl -s -H "Authorization: Bearer $TGA_KEY" \
     "https://www.trackagoat.com/api/v2/payout-structures/$STRUCTURE_ID/assignments" \
     | jq '[.data[] | select(.unassigned_at == null) | .creator_id]'