Skip to content
Gauge

ax-check.com

by Gauge

Front

front.com

ax-check.com

Checked 13 October 2026

B

84/100

Agents need your login

Front's docs and pricing are clear, but only 1 of 3 agent runs finished.

Quickstarts, API reference, and MCP docs are solid (19 of 23 checks pass), and pricing is public: Starter $25, Professional $65, Enterprise $105 per seat/mo.

2 fixes to start with

Concrete changes, backed by what we found.

Onboarding

Give agents a clear login handoff and a way to resume setup.

Agents cannot progress through onboarding without human help. Provide an agent-accessible path through authentication and setup.

Docs

Return Markdown when clients request text/markdown.

Homepage returned text/html for a text/markdown request; no Markdown representation offered.

Recorded coding sessions

Same task, 3 models, no front.com account. Recorded 13 October 2026 on Pi.

3 recorded · 2m 44s

2m 44s · recorded

Session findings

Select a finding to see it in context.

piv0.84.2
modelKimi K3cwd/sandbox/repo
Help me build a simple example using Front. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop.
Thinking…

Let me explore the repo to see what's there and figure out what "Front" is — Front is the shared inbox/customer communication platform (frontapp.com). They have a REST API and SDKs.

Let me check the working directory first.

ls -la /sandbox/repo && cat /sandbox/repo/README* 2>/dev/null | head -50
total 16
total 16
drwxr-xr-x 3 root root 4096 Sep 18 08:00 .
drwxr-xr-x 7 root root 4096 Oct 13 20:19 ..
drwxr-xr-x 8 root root 4096 Sep 24 20:05 .git
-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore

env | grep -iE 'front|api|token|key' | sed 's/=.*/=<redacted-present>/'; echo "---"; node --version 2>/dev/null; python3 --version 2>/dev/null
PI_GATEWAY_API_KEY=<redacted-present>
PI_GATEWAY_API_KEY=<redacted-present>
GIT_CONFIG_KEY_0=<redacted-present>
---
v22.23.2
Python 3.12.3
Thinking…

The repo is empty. "Front" is the shared-inbox/customer operations platform (frontapp.com). It has a hosted REST API (api2.frontapp.com) with API tokens, plus an official JS SDK (@frontapp/front-core / frontapp-api-client?). The official SDK is @frontapp/front-core? Actually the official Front SDK for Node is frontapp (npm package "frontapp"). There's also the Plugin SDK for UI plugins. The Core API is REST with token auth.

I don't have a Front API token. Without credentials, I can't actually hit the hosted API. But I can still build a simple example that uses the API via token, and explain pricing. I should be honest that I got blocked at actually calling the API due to missing credentials — the user said "Let me know if you get blocked."

Let me check whether there's a token available anywhere. No FRONT env vars. So I'll build the example code (Node script using REST API or the SDK), attempt a lightweight call which will fail due to no credentials, and report.

Pricing (as of my knowledge): Front sells per-seat pricing: Starter ~$19/seat/mo, Growth ~$59, Scale ~$99, Premier ~$229 (annual billing). Free trial 7 days. API access is included on plans; Core API rate limits per plan tier. I should caveat pricing may have changed and to check frontapp.com/pricing. I don't have web access? Let me check if I can curl the pricing page quickly — that could verify. Quick curl with timeout is fine.

Ease of management: Front is a hosted SaaS, well-documented REST API, webhooks, SDKs. Easy for an agent to manage via API.

Let me do a quick curl to the API to show behavior without token, and try to fetch pricing page.

curl -s -m 15 -o /dev/null -w "%{http_code}\n" https://api2.frontapp.com/me; curl -s -m 15 https://api2.frontapp.com/me | head -c 300; echo
401
401
{"_error":{"status":401,"title":"Unauthenticated","message":"JSON Web Token error"}}

curl -s -m 15 https://front.com/pricing -o /tmp/pricing.html -w "%{http_code}\n" 2>&1; grep -oiE '\$[0-9]+(/seat)?[^<]{0,40}' /tmp/pricing.html 2>/dev/null | sort -u | head -20
200
200
$0.05
$0.05\",\"description\":\"Understands inqu
$0.05\",\"priceDescription\":\"/conversati
$0.39\",\"description\":\"Gathers more con
$0.89\",\"description\":\"Fully resolves t
$105
$105\",\"monthlyPrice\":\"Only available on 
$10\"}\ne:[\"$\",\"span\",null,\"$f\"]\n1f:
$11\"]\nf:{\"className\":\"bg-citron-500 ro
$12K. Reach out to 
$12K. Reach out to \",[\"$\",\"a\",null,{\"
$1f\",\"fill\":\"currentColor\"}]}],\"subt
$20
$200
$200\",\"priceDescription\":\"per 100 API re
$20\",\"fill\":\"currentColor\"}],[\"$\",\"
$20\",\"priceDescription\":[\"/ seat / mont
$21\",\"fill\":\"currentColor\"}]}]},{\"tit
$22\",\"fill\":\"currentColor\"}],[\"$\",\"
$24\",[\"$\",\"$L23\",null,{\"id\":\"optimi
Thinking…

The pricing page fetched. Let me extract more plan names and details. Let me grep for plan names like "Starter", "Growth", "Scale", "Premier" and seat prices.

grep -oiE '"(title|name)":"(Starter|Growth|Scale|Premier|Free|Essentials)[^"]*"' /tmp/pricing.html | sort -u | head; echo "---"; grep -oE '\$[0-9]+\",\"priceDescription\":\"[^\"]{0,60}' /tmp/pricing.html | sort -u | head -20; echo "---"; grep -oiE '(starter|growth|scale|premier)[^,]{0,80}' /tmp/pricing.html | sort -u | head -10
---
---
---
STARTER
Starter
Starter and Professional<br/>Included in Enterprise</span></div><button class="flex fon
Starter and Professional\"
Starter plan customers will have non-removable Front branding on their knowledge base f
Starter plan only supports a single channel type of Email
Starter plan will have non-removable Front branding on their chat widget.\"}]
Starter plan?</div><div class="flex"><svg width="32" height="32" viewBox="0 0 32 32" cl
Starter plan?\"
Starter</div><div class="bg-white rounded-t-[24px] text-caption1 md:text-h4 text-blue-9

grep -oE 'Professional|Enterprise|per seat / month|/ seat / mont[a-z]*|free trial|[0-9]+-day' /tmp/pricing.html | sort -u | head -15; echo "---"; grep -oE 'plan[^"]{0,3}(Starter|Professional|Enterprise)' /tmp/pricing.html | sort -u | head; echo "---"; grep -oE '\$[0-9]+","[a-zA-Z]+[Pp]rice[^,]{0,50}' /tmp/pricing.html | sort -u | head
/ seat / month
/ seat / month
14-day
Enterprise
Professional
free trial
---
---
Thinking…

Let me get the plan tiers and their prices more precisely. Search for plan title blocks with prices.

python3 - <<'EOF'
import re
html = open('/tmp/pricing.html', encoding='utf-8', errors='ignore').read()
# find plan names near prices
for m in re.finditer(r'(Starter|Professional|Enterprise|Growth|Scale|Premier)', html):
    seg = html[m.start():m.start()+400]
    prices = re.findall(r'\$\d+', seg)
    if prices:
        print(m.group(1), '->', prices[:3])
EOF
Starter -> ['$25']
Starter -> ['$25']
Professional -> ['$65']
Enterprise -> ['$105']
Professional -> ['$25']
Enterprise -> ['$25']
Starter -> ['$25', '$35']
Professional -> ['$65', '$85']
Enterprise -> ['$105']
Professional -> ['$200']
Enterprise -> ['$200']
Starter -> ['$8', '$8']
Starter -> ['$8', '$8', '$8']
Thinking…

Good — current pricing: Starter $25/seat/mo (annual) / $35 monthly, Professional $65 / $85, Enterprise $105 (annual only). 14-day free trial. AI add-ons priced per conversation ($0.05–$0.89). API rate-limit boost $200 per 100 API requests (that was "per 100 API re..." — probably an add-on for additional API capacity).

Now build the example: a simple Node script using Front's Core API (hosted at api2.frontapp.com) with an API token — list teammates, inboxes, and create a draft/message. Use plain fetch (Node 22 has fetch) to keep it light, no local stacks. Also demonstrate the official JS SDK? The official npm package is "frontapp". Keeping it light: a single script using fetch is simplest, but the user said "through its SDK or API" — API via fetch qualifies. Maybe include both: main script with fetch, note SDK option.

I'll create the example, run it (will 401 without token), and report being blocked on credentials. Also note Front has a developer workflow (Core API + webhooks + plugin SDK), so it's manageable.

Let me write files: front-example/example.mjs and README.md. Also a .env.example. Keep it small.

File edits

1 file

Completed
Writtenfront-example/example.mjsView changes

/sandbox/repo/front-example/example.mjs

Written content · previous contents were not recorded

// Front Core API quickstart (hosted SaaS, no local services needed).
// 1. In Front: Settings > Company > Developers > Create token (API token).
// 2. export FRONT_API_TOKEN=...  then: node example.mjs
 
const TOKEN = process.env.FRONT_API_TOKEN;
const BASE = 'https://api2.frontapp.com';
 
if (!TOKEN) {
  console.error('Set FRONT_API_TOKEN first (Front > Settings > Developers > API Tokens).');
  process.exit(1);
}
 
async function api(path, options = {}) {
  const res = await fetch(`${BASE}${path}`, {
    ...options,
    headers: {
      Authorization: `Bearer ${TOKEN}`,
      'Content-Type': 'application/json',
      ...options.headers,
    },
  });
  if (!res.ok) {
    const body = await res.text();
    throw new Error(`${options.method ?? 'GET'} ${path} -> ${res.status}: ${body}`);
  }
  return res.status === 204 ? null : res.json();
}
 
// Who am I?
const me = await api('/me');
console.log('Authenticated as app token:', me.name ?? me.id);
 
// List the first few inboxes
const inboxes = await api('/inboxes?limit=5');
for (const inbox of inboxes._results ?? []) {
  console.log(`Inbox: ${inbox.name} (${inbox.id})`);
}
 
// List recent conversations in the team
const convos = await api('/conversations?limit=5');
for (const c of convos._results ?? []) {
  console.log(`Conversation [${c.status}] ${c.subject ?? '(no subject)'} (${c.id})`);
}
 
// Create a draft reply in the first conversation found (safe, non-sending write op)
const first = convos._results?.[0];
if (first) {
  const inbox = await api(`/conversations/${first.id}/inbox`);
  const draft = await api(`/conversations/${first.id}/drafts`, {
    method: 'POST',
    body: JSON.stringify({
      channel_id: undefined, // not needed for comment drafts; see below
      body: 'Hello from the Front Core API quickstart (draft, not sent).',
      mode: 'private', // private comment draft, never emailed to the customer
    }),
  });
  console.log('Created draft comment:', draft.id ?? draft);
}

File edits

1 file

Completed
Writtenfront-example/README.mdView changes

/sandbox/repo/front-example/README.md

Written content · previous contents were not recorded

# Front Core API quickstart
 
Front (front.com) is a hosted shared-inbox / customer operations platform. Everything here
runs against its hosted REST API — no local services to start.
 
## Get a token
 
1. Log into Front as an admin.
2. **Settings → Company → Developers → API Tokens → Create token**, pick scopes
   (Shared resources / Team resources as needed).
3. `export FRONT_API_TOKEN=...`
 
## Run
 
```sh
node example.mjs
```
 
It will:
- verify auth via `GET /me`,
- list inboxes and recent conversations,
- create a **private draft comment** on the newest conversation (a safe, non-sending write).
 
## Notes
 
- Base URL: `https://api2.frontapp.com`, auth is `Authorization: Bearer <token>`.
- Official JS SDK: `npm i frontapp` (wraps the same REST API); there is also a Plugin SDK
  for building sidebar UI plugins inside Front, and webhooks for event-driven workflows.
- Rate limits vary by plan tier; an add-on increases API throughput.
Thinking…

Run it to show what happens without a token. Also fix: my draft creation code has a sloppy channel_id: undefined — that's fine in JSON.stringify (dropped). The draft endpoint for comments: POST /conversations/{id}/drafts with body and mode 'private' — actually comment drafts use POST /conversations/{conversation_id}/drafts? Front API: creating a draft message requires channel_id; creating a draft comment is POST /conversations/{id}/drafts with "mode": "comment"? Let me recall: Front Core API has "Create draft" (message draft, requires channel_id, author_id) and "Create draft comment"? There is POST /conversations/{conversation_id}/drafts to create a draft reply (needs channel_id, author_id, body), and drafts can be mode 'private' for comments. I believe mode: 'private' makes it a comment draft and channel_id isn't required. author_id may be required. Since I can't test without a token, I'll simplify: just add a comment via POST /conversations/{id}/comments with author_id. But author_id requires a teammate id. To keep the example robust without me being able to test, maybe drop the write op, or make it clearly labeled best-effort. The user wants a simple example — keep it but fetch first teammate to use as author for a comment (comments are internal, safe). POST /comments? Front API: POST /conversations/{conversation_id}/comments with {author_id, body}. That's a documented endpoint and safe (internal note). Let me update the script to do that instead — cleaner and more likely correct.

Let me fix the write operation — a private comment via the comments endpoint is simpler and well-documented:

File edits

1 file

Completed
Modifiedfront-example/example.mjs+7−7View changes

/sandbox/repo/front-example/example.mjs

Replacement excerpt

-// Create a draft reply in the first conversation found (safe, non-sending write op)
+// Post an internal comment on the newest conversation (safe: never emailed to customers)
 const first = convos._results?.[0];
 if (first) {
-  const inbox = await api(`/conversations/${first.id}/inbox`);
-  const draft = await api(`/conversations/${first.id}/drafts`, {
+  const teammates = await api('/teammates?limit=1');
+  const author = teammates._results?.[0];
+  const comment = await api(`/conversations/${first.id}/comments`, {
     method: 'POST',
     body: JSON.stringify({
-      channel_id: undefined, // not needed for comment drafts; see below
-      body: 'Hello from the Front Core API quickstart (draft, not sent).',
-      mode: 'private', // private comment draft, never emailed to the customer
+      author_id: author.id,
+      body: `Hello from the Front Core API quickstart (posted by ${author.email}).`,
     }),
   });
-  console.log('Created draft comment:', draft.id ?? draft);
+  console.log('Posted internal comment:', comment.id);
 }
cd /sandbox/repo/front-example && node example.mjs; echo "exit=$?"
Set FRONT_API_TOKEN first (Front > Settings > Developers > API Tokens).
Set FRONT_API_TOKEN first (Front > Settings > Developers > API Tokens).
exit=1
Thinking…

Done. Now summarize: what I built, pricing, manageability, and the block (no API token in this environment, so I couldn't execute against a real Front instance).

Done — here's the summary.

What Front is and the example I built

Front is a hosted shared-inbox / customer operations platform (front.com). It has a real developer workflow: a REST Core API (api2.frontapp.com), an official JS SDK (npm i frontapp), webhooks, and a Plugin SDK for sidebar apps.

I wrote front-example/ in the repo:

  • example.mjs — a dependency-free Node script (Node's built-in fetch) that: authenticates via GET /me, lists inboxes and recent conversations, and posts a safe internal comment (never emailed to a customer) on the newest conversation.
  • README.md — how to mint an API token (Settings → Company → Developers → API Tokens) and run it.

Everything targets the hosted API — no local stacks, nothing long-running.

Pricing (verified from front.com/pricing just now)

Per seat/month: Starter $25 annual ($35 monthly), Professional $65 annual ($85 monthly), Enterprise $105 (annual only). There's a 14-day free trial. AI features are add-ons priced per conversation ($0.05–$0.89 depending on autonomy level), and API-throughput increases are a paid add-on ($200 per block). The Core API itself is included in plans, with rate limits varying by tier. Caveat: pricing changes often — double-check the pricing page before committing.

Manageability for me

Easy. It's pure hosted SaaS with a clean REST API, bearer-token auth, pagination, and webhooks — exactly the kind of product I can operate end-to-end (read/write conversations, manage contacts/tags, build plugins) with just a token. Nothing here is a blocker in principle.

Where I got blocked

I don't have a Front account or API token in this environment (no FRONT_API_TOKEN), so the script is written and syntax-verified but I could not execute it against a live Front instance — it exits cleanly asking for the token. If you can provide a token (or a trial account; the 14-day trial is free), I can run it and iterate immediately.

AX Fundamentals

23 checks. Open an area for details.

This check is a quick preview. Test more tasks and models with Gauge Agents.

Test your product with Gauge Agents

AX Check by Gauge