Claude Code for Amazon Sellers: Automate a Sourcing Report

Claude on the web is where most sellers start with AI sourcing. If you live in a terminal or an editor, Claude Code and Cursor do the same job from your own machine, and they open a door the chat apps do not: scripts. One connection key lets Claude Code call your Arbitrage Stalker data, and the same key works over plain HTTP, so a short script can run your sourcing check every morning on a schedule.

Below is the setup for both tools, a scheduled morning report you can copy, how to handle refusals, and how to keep the key safe.

Claude Code and Cursor use a connection key

The chat apps connect with a sign-in and an Allow button. Tools that run on your computer take a key instead. If you set up Claude on the web already, the Claude connection guide covers that side.

To get a key:

1. In Arbitrage Stalker, open AI Connection Keys from Settings, under Devices and keys.
2. Name the key after where it will live, like "Claude Code on my laptop" or "Cursor at the office." When you revoke one later, the name is how you tell them apart.
3. Click Create key and copy it right away. It starts with as_mcp_. This is the only time the app shows it. If you lose it, revoke it and make another.

Connect Claude Code

One command in your terminal. Put your key in place of the placeholder:

claude mcp add --transport http arbitrage-stalker https://app.arbitragestalker.com/mcp --header "Authorization: Bearer as_mcp_YOUR_KEY_HERE"

Start Claude Code and type /mcp. You should see arbitrage-stalker listed as connected. Ask "how many sellers am I tracking?" to confirm it can see your account.

Connect Cursor

1. Open Settings, then MCP, and choose Add new MCP server.
2. Pick HTTP as the type and enter https://app.arbitragestalker.com/mcp as the URL.
3. Add a header called Authorization with the value Bearer as_mcp_YOUR_KEY_HERE.
4. Save. The server shows a green dot once Cursor connects and loads the tools.

From there, everything that works in the chat apps works in your terminal or editor: lead searches, eligibility checks, profit math through the app's calculator, storefront feeds. The full MCP server page lists the tools.

The REST bridge: same tools, plain HTTP

Your connection key also works without any MCP client. Add /tools to the server address and you get every tool and the arguments it takes:

curl https://app.arbitragestalker.com/mcp/tools -H "Authorization: Bearer as_mcp_YOUR_KEY_HERE"

To call a tool, POST its arguments as JSON. This one pulls what your tracked sellers added since a date, for one brand, oldest first:

curl -X POST https://app.arbitragestalker.com/mcp/tools/storefront_feed \
  -H "Authorization: Bearer as_mcp_YOUR_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{"found_since": "2026-10-13", "brands": ["Nike"], "sort": "oldest"}'

A successful call returns the tool name and its result. Your credits, limits and rate caps match what your AI app gets, so a script cannot spend more than you could in a chat.

A scheduled morning sourcing report

The job I want done before I sit down: pull everything my tracked sellers added since the last run, drop listings with Amazon on them and slow movers, and save the result. The storefront_feed tool returns a latest_found_at value on each run. Store it, pass it back as found_since next time, and you never see the same find twice.

Run the storefront_feed curl above once by hand and read the output, so you know the response shape. The script below searches the response for the fields it needs, so it does not depend on the nesting.

#!/usr/bin/env bash
# morning-report.sh: new finds from tracked sellers since the last run
set -euo pipefail

KEY="$(cat "$HOME/.as-mcp-key")"
STATE="$HOME/.as-feed-since"
OUT="$HOME/sourcing/$(date +%F).json"
SINCE="$(cat "$STATE" 2>/dev/null || date -d yesterday +%F)"
mkdir -p "$(dirname "$OUT")"

CODE=$(curl -s -o "$OUT" -w "%{http_code}" \
  -X POST https://app.arbitragestalker.com/mcp/tools/storefront_feed \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d "{\"found_since\": \"$SINCE\", \"sort\": \"oldest\", \"hide_amazon\": true, \"max_bsr\": 100000, \"limit\": 100}")

if [ "$CODE" = "422" ]; then
  echo "Refused: $(jq -r '[.. | .code? // empty] | first' "$OUT")" >&2
  exit 2
elif [ "$CODE" != "200" ]; then
  echo "HTTP $CODE" >&2
  exit 1
fi

NEXT=$(jq -r '[.. | .latest_found_at? // empty] | first // empty' "$OUT")
[ -n "$NEXT" ] && echo "$NEXT" > "$STATE"
echo "Saved $OUT"

A few notes on it:

• It reads the key from a file, so the key never sits in the script or your crontab. Run chmod 600 ~/.as-mcp-key so only your user can read it.
• date -d yesterday is GNU syntax. On a Mac, use date -v-1d +%F.
• The feed returns up to 100 rows per page. If the response says has_more is true, call again with "page": 2 and the same arguments.
• It needs jq installed.

Turn the JSON into a shortlist

Raw JSON is not a report. Pipe it to Claude Code in print mode and ask for the shortlist:

cat ~/sourcing/$(date +%F).json | claude -p "From this storefront feed, list the ten products with the best rank, with brand, buy box price and the seller who added each one."

Or open Claude Code later and ask it to check eligibility and profit on the file's ASINs. With the MCP server connected, it calls check_eligibility and calculate_profit for you.

Schedule it with cron (Mac or Linux)

Open your crontab with crontab -e and add a line to run it at 7:30 every morning:

30 7 * * * /home/you/morning-report.sh >> /home/you/sourcing/report.log 2>&1

Schedule it with Task Scheduler (Windows)

With Git Bash installed, one schtasks command, run from a Command Prompt, registers a daily run:

schtasks /Create /SC DAILY /ST 07:30 /TN "AS morning report" /TR "\"C:\Program Files\Git\bin\bash.exe\" -lc ~/morning-report.sh"

Handling 422 refusals

When a tool refuses a call, the REST bridge returns HTTP 422 with an error message and a code your script can check. Two you will see:

• out_of_credits: you are out of Apex credits. The free tools still work. Top up on the credits page.
• quota_reached: you hit a limit. Stop and try again later instead of hammering the endpoint.

storefront_feed is free, so the morning report above should not hit out_of_credits. Credit-spending tools are a different story: a fresh Apex Read costs 1 credit, batch scoring costs 1 credit per uncached ASIN, importing a never-seen product costs 1 credit, and listing a brand's catalog costs 10 credits with a daily cap. If a script calls those, check for 422 on every call and exit on the first refusal instead of looping.

Batch scoring has a safety built in: by default it quotes the cost and spends nothing until you call it again with confirmation. Keep that default in scripts.

Keep the key safe

Treat a connection key like a password. Anyone holding it can read your leads and spend your Apex credits.

• Keep it out of shared docs, Slack channels and public repos. A key in a committed script is a leaked key.
• Use one key per machine or tool, named after where it lives, so you can revoke one without breaking the rest.
• If you think a key leaked, revoke it under AI Connection Keys. The client holding it loses access on its next request.
• Arbitrage Stalker logs every request against the key that made it, so you can see what each connection has been doing.

The key can read your Arbitrage Stalker data and spend credits at app prices. It cannot touch your password, billing or Seller Central. For the wider question of what an AI should and should not be allowed to touch on your account, I wrote is it safe to connect AI to Seller Central.

If it does not connect

• 401 or Unauthorized: the key is wrong or expired, or Bearer is missing. The header value must be Bearer as_mcp_... with a single space.
• "Not authorized for the MCP server": you pasted a public API key. Those start with as_live_. Connection keys start with as_mcp_.
• 404 or "Not found": every paid plan includes AI connections. If you pay and still see this, contact support.

Chat, Claude Code or a script?

All three hit the same tools with the same limits, so pick by the job.

• Claude or ChatGPT on your phone: quick questions away from your desk. "Is this worth buying at $12?" in a store aisle.
• Claude Code or Cursor: working with files. Point it at a supplier sheet in your project folder, ask it to match the UPCs and check eligibility, and have it write the results to a new CSV next to the original.
• A script on a schedule: jobs you want done the same way every day, whether or not you remember. The morning feed is the obvious one.

Claude Code sits in the middle. It can read the JSON your script saved, call more tools through the MCP connection, and write a summary file, all in one session.

A weekly roster check

The same bridge handles a weekly look at your store roster. This call returns your tracked sellers sorted by yield, lowest first, so the dead slots sit at the top:

curl -X POST https://app.arbitragestalker.com/mcp/tools/list_tracked_sellers   -H "Authorization: Bearer $(cat ~/.as-mcp-key)"   -H "Content-Type: application/json"   -d '{"sort": "yield_asc", "limit": 50}'

Each row carries new_products_7d and new_products_30d. A store with zero in 30 days is a slot you could give to a better one. Schedule it for Monday mornings with a second cron line, and decide who to cut over coffee.

What to automate next

The morning feed is the easiest win. Once it runs, the same pattern works for a weekly roster check with list_tracked_sellers, which shows each store's new products over 7 and 30 days, so you can spot dead store slots. I covered how to read that yield and run the daily digest by chat in AI storefront stalking. For automation ideas beyond the API, see online arbitrage automation.

The Arbitrage Stalker MCP server and its REST bridge come with every paid plan. Compare Scout, Hunter and Predator on the pricing page, then create your account, mint a connection key and run the /tools call to see what you can automate.