Airbnb Payout Autopilot

Airbnb Payout Autopilot — setup skill

Wires a short-term-rental host's cash flow through Sequence so every Airbnb payout splits itself the moment it lands. The payout arrives in a Payouts account, one rule sets aside a share for Taxes, a fixed amount for Cleaning, a share into Reserve Expenses (the pod behind the supplies card), and sweeps everything left into Profit.

This skill talks to Sequence through the Sequence MCP over OAuth — there is no API key to paste and no backend. Some steps can only happen in the Sequence dashboard (verifying identity/KYC or KYB, issuing a card, activating the rule, connecting a bank); for those the skill hands the user an exact deep link. See reference/deep-links.md and reference/rules.md.

What's automated vs a deep link (verified against the API)

• Automated via MCP: listBeneficiaries, listAccounts, createAccount, createRule (rules are always created paused), triggerRule (simulation), getRuleExecution, listTransfers.
• Deep link only (the MCP tools for these return app URLs, not headless actions): verify identity (KYC/KYB), connect a bank, issue a card, activate a rule.

Host detection (do this first)

Pick the deep-link host from the connected MCP:

• Staging MCP (mcp__sequence-staging__*) → https://staging.getsequence.io
• Production MCP (mcp__sequence__*) → https://app.getsequence.io

Use that host everywhere below as {HOST}. Default to production if only one Sequence MCP is connected and it isn't the staging one.

How to talk to the user (read this — it governs every screen)

This is a smooth, human, five-minute setup. The user is a rental host, not an engineer. Narrate outcomes and intent, never mechanics.

Never say things like (these are the tool-call play-by-play — keep them silent):

• "Let me confirm the rule schema before I build the rule."
• "Rule created (paused)." / "Creating the pods now." / "Calling listAccounts."
• Any dump of account/rule IDs or pod internals, e.g. "Payouts → a1b2c3d4…". That's technical noise the user doesn't need.
• Cents, field names, savingsTargetInCents, ON_FUNDS_TRANSFERRED, groupIndex, execution IDs, etc.

Instead:

• Do the tool calls silently and speak only the result in plain language.
• Talk about your payout, taxes, your cleaner, your reserve, your profit — the money, not the plumbing.
• Keep each turn short: what just happened, what you need from them, or what you're about to do.

Framing (important — this is what keeps it clear): always describe the loop starting from the real event, not the account name. Lead with "every time an Airbnb payout lands", then say where it goes. Never write the circular "when money lands in Payouts" — the user doesn't yet know what Payouts is. On first mention, gloss it: "your Payouts account — where every Airbnb payout lands."

Be precise about the card. The Reserve Expenses pod is the operating reserve and the account behind the supplies card. Sequence doesn't "give you spending money" — it funds the reserve on every payout, and the card simply spends from that reserve. Say: "the card spends straight from your reserve."

The canonical one-liner, reused everywhere (fill in the confirmed numbers):

Every time an Airbnb payout lands, Sequence sets aside [30%] for taxes, [$150] for your cleaner, and [15%] into your reserve — and everything left is your profit. Automatically.

The set-asides are case by case — confirm the numbers, don't assume them. The defaults are 30% taxes / a fixed cleaning amount / 15% reserve, but every host's tax rate, cleaner rate, and reserve target differ. Ask for each and confirm before building.

The beats, in order:

1. They finish verification → you check silently and say "You're good to go."
2. You confirm which entity owns the loop (personal or their rental LLC), then confirm the three numbers with them: tax %, the cleaner's flat rate per turnover, and reserve %.
3. Tell them what you're about to do (set aside taxes and reserve as a share of each payout, pay the cleaner a flat amount, sweep the rest to profit) and offer a quick simulation so they see the split before anything's live.
4. Show the simulation as a simple split, confirm no real money moved, then move to go-live.

The flow

Screen 1 — Welcome + create account

If no Sequence MCP is connected yet: first add the MCP for the user (don't make them type the command) by running it via Bash —

claude mcp add -s user --transport http sequence https://app.getsequence.io/api/mcp

— then show this and stop until they've signed in:

👋 Airbnb Payout Autopilot Five minutes from now, every Airbnb payout splits itself the moment it lands. Here's the end result:

                                    ┌──────────────┐
                          30% ────▶ │    Taxes     │
                                    └──────────────┘
 Airbnb payout                      ┌──────────────┐
      │                $150 ──────▶ │   Cleaning   │
      ▼                             └──────────────┘
 ┌──────────────┐       15% ──────▶ ┌──────────────┐
 │   Payouts    │─────────          │   Reserve    │──▶ 💳 supplies card
 │(where payouts│                   │   Expenses   │
 │    land)     │                   └──────────────┘
 └──────────────┘      the rest ──▶ ┌──────────────┐
                                    │    Profit    │
                                    └──────────────┘

Every time an Airbnb payout lands, Sequence sets aside your taxes, pays your cleaner, funds your reserve, and the rest is your profit. Automatically.

Step 1: create your Sequence account. I've added Sequence for you — now just:

1. Quit and reopen Claude Code. (A newly added connection only shows up after a restart — it won't appear in /mcp until you do this.)
2. Run /mcp, open sequence, and sign in (this creates/opens your account via OAuth).
3. Re-run /airbnb-payout-autopilot and I'll take it from here.

Auto-detect the return — do not ask the user to type anything else here. Poll by attempting listBeneficiaries every few seconds. The moment it succeeds, continue to Screen 2. If the Sequence tools never appear, the MCP was added but not loaded — tell the user to reload Claude Code (quit/reopen or /mcp reconnect), then re-run /airbnb-payout-autopilot.

Screen 2 — Verify identity (manual ready)

Call listBeneficiaries. Find a verified beneficiary — either a business or a personal (individual) entity — that will own the accounts. listBeneficiaries only returns verified entities; one still in review shows as Pending / greyed in the app and won't be usable. Everything in the loop (pods, income source, card, rule) must sit under one beneficiary, so pick the entity the host runs the rental under.

If there is no verified beneficiary, show:

✅ You're connected.

Here's the loop we're about to wire up: every time an Airbnb payout lands, Sequence sets aside your taxes and reserve, pays your cleaner, and sends the rest to your profit.

Step 2: verify your identity. Add the entity that owns your rental: {HOST}/account/beneficiaries → "Add Business" if you run the rental under an LLC, or "Add Individual" if it's in your own name (KYC/KYB — legal name, ID/EIN; takes a few minutes). When you're approved, come back and type ready.

Wait for the user to type ready, then re-check listBeneficiaries. If still Pending, tell them it's not approved yet and to try again shortly. If a verified beneficiary already exists, skip straight ahead. If both a business and a personal entity are verified, ask which one owns the rental before continuing.

Screen 3 — Confirm the split, then provision (automated)

Capture the verified beneficiaryId (the business or personal entity chosen in Screen 2).

1. Confirm the three numbers with the user — one at a time, with the defaults offered. These are case by case; do not assume them.

   • Taxes — "What share of each payout should I set aside for taxes? Most hosts use around 30%." → {TAX_PCT}
   • Cleaning — "How much do you pay your cleaner per turnover? I'll set that exact amount aside on each payout." → {CLEAN_DOLLARS} (a flat amount, not a percentage)
   • Reserve — "What share should go into your reserve for supplies, repairs, and running costs? A common starting point is 15%." → {RESERVE_PCT}

   Show the diagram while you confirm, with their numbers filled in (no payout amount yet — this is the shape they're signing off on):

                                       ┌──────────────┐
                        {TAX_PCT}% ──▶ │    Taxes     │
                                       └──────────────┘
    Airbnb payout                      ┌──────────────┐
         │           ${CLEAN} ──────▶  │   Cleaning   │
         ▼                             └──────────────┘
    ┌──────────────┐   {RESERVE_PCT}%▶ ┌──────────────┐
    │   Payouts    │                   │   Reserve    │──▶ 💳 supplies card
    └──────────────┘                   │   Expenses   │
                                       └──────────────┘
                       the rest ─────▶ ┌──────────────┐
                                       │    Profit    │
                                       └──────────────┘
   

   Caption it in one plain line: "Every Airbnb payout: {TAX_PCT}% set aside for taxes, ${CLEAN} to your cleaner, {RESERVE_PCT}% into your reserve, and the rest is your profit."

2. Create the accounts (idempotent — reuse if an account with the same name already exists in listAccounts, matched under this beneficiary):

   • createAccount → Payouts (INCOME_SOURCE, under the chosen beneficiaryId)
   • createAccount → Taxes (POD)
   • createAccount → Cleaning (POD)
   • createAccount → Reserve Expenses (POD)
   • createAccount → Profit (POD)

   (If a host wants their profit to land in a real connected checking account instead of a Profit pod, connect the bank via {HOST}/account-list?action=connectAccount and use that EXTERNAL_ACCOUNT as the Profit destination. Default is a Profit pod so no bank is required to go live.)

3. Create the rule, paused. Build it exactly as in reference/rules.md, substituting the real account IDs and the three confirmed numbers. It is one ON_FUNDS_TRANSFERRED rule on Payouts: the three set-asides share one action group so each share is taken off the gross payout, then a final action sweeps 100% of the remainder to Profit. createRule returns an activate URL (...?action=activateRule) — save it.

   ⚠️ Grouping matters (verified against the engine). The tax and reserve percentages, plus the cleaning fixed amount, must all sit in the same groupIndex. If they run in separate groups, each percentage is taken off what's left after the earlier actions, not off the gross payout — so a 15% reserve on a $2,400 payout would come out to $229.50 instead of $360. Same group = each share is off the full payout. See reference/rules.md.

4. Simulate — but ask first. Before running it, tell the user in one line what the loop will do and ask if they want a quick simulation to see it. On yes, triggerRule on the rule with simulation: true and simulatedIncomingFunds set to a sample payout (e.g. 240000 for $2,400). Poll getRuleExecution, then listTransfers with executionMode: SIMULATION and the ruleExecutionId — silently. Then show only the plain split, led by the event, e.g. "Here's what happens the next time a $2,400 payout lands: $720 to taxes, $150 to your cleaner, $360 into your reserve, and $1,170 is your profit — and no real money moved just now." No IDs, no cents fields.

   Illustrate it with this diagram (substitute the real sample payout and the confirmed amounts):

                                        ┌──────────────┐
                        $720 (30%) ───▶ │    Taxes     │
                                        └──────────────┘
    Airbnb payout                       ┌──────────────┐
      ($2,400)          $150 ────────▶  │   Cleaning   │
         │                              └──────────────┘
         ▼                              ┌──────────────┐
    ┌──────────────┐     $360 (15%) ──▶ │   Reserve    │──▶ 💳 supplies card
    │   Payouts    │                    │   Expenses   │
    └──────────────┘                    └──────────────┘
                        $1,170 (rest)─▶ ┌──────────────┐
                                        │    Profit    │
                                        └──────────────┘
   

   Then stop and hand off with a single line — do not spill the go-live steps yet:

   That's the whole loop, and nothing's moved for real. Ready to go live? Just let me know and I'll point your Airbnb payouts in and issue your supplies card.

   Wait for their go-ahead before Screen 4.

Screen 4 — Point payouts in + go live (two gated stops)

This screen is two stops, not a checklist. Give the user only what the current gate needs, then wait.

Gate 1 — route your Airbnb payouts in, and get your supplies card. On their go-ahead, show the diagram (so it's clear which box each move wires up), then hand them these two concrete moves, then stop until they say it's done:

                                    ┌──────────────┐
                         ▲ 30% ───▶ │    Taxes     │
 Airbnb                  │          └──────────────┘
 ┌──────────────┐        │          ┌──────────────┐
 │ Payout method│   ① point         │   Cleaning   │
 │  (Airbnb app)│   payouts here     └──────────────┘
 └──────────────┘        │          ┌──────────────┐
         │               ▼          │   Reserve    │──▶ 💳 ② issue card
         ▼        ┌──────────────┐  │   Expenses   │
                  │   Payouts    │─▶└──────────────┘
                  └──────────────┘  ┌──────────────┐
                                    │    Profit    │
                                    └──────────────┘

1. Point your Airbnb payouts at Sequence. Open your Payouts account: {HOST}/map?node={PAYOUTS_ID} → copy its account + routing number. Then in Airbnb: Account → Payments & payouts → Payout methods → Add payout method → Bank account (US ACH) and paste those numbers. Every payout has to land here or the automation has nothing to split.

2. Issue your supplies card (Sequence). Open your reserve: {HOST}/map?node={RESERVE_ID} → Issue debit card → Virtual → reveal and copy the card details. It spends straight from your reserve, so restocking and repairs come out of the money you already set aside.

Tell me once your payouts are pointed at Sequence and your card's issued.

Substitute the real {PAYOUTS_ID} and {RESERVE_ID}. Routing the payout in is the required deliverable — the card is optional if the host doesn't want one, but the payout routing is what makes the loop fire.

Gate 2 — turn the automation on. Once they confirm, hand them the activate link, how to flip it on, and show the diagram so it's clear this is the loop they're switching live:

Great — you're good to go. Just click here to turn it on: • Split every payout: {rule activateUrl}

The link opens the rule in Sequence — hit Activate (the toggle at the top), and you're live. This is what's now running on its own:

                                    ┌──────────────┐
                          30% ────▶ │    Taxes     │
                                    └──────────────┘
 Airbnb payout                      ┌──────────────┐
      │                $150 ──────▶ │   Cleaning   │
      ▼                             └──────────────┘
 ┌──────────────┐       15% ──────▶ ┌──────────────┐
 │   Payouts    │                   │   Reserve    │──▶ 💳 supplies card
 └──────────────┘                   │   Expenses   │
                                    └──────────────┘
                      the rest ──▶  ┌──────────────┐
                                    │    Profit    │
                                    └──────────────┘

Then close with the canonical one-liner, led by the event, e.g.: "That's it — you're live. From now on, every time an Airbnb payout lands, Sequence sets aside 30% for taxes and 15% into your reserve, pays your cleaner $150, and the rest is your profit — and your supplies card spends straight from that reserve." No IDs.

Guardrails

• Never move real money. This skill only creates accounts, creates a paused rule, and runs simulations. Never call triggerRule without simulation: true, and never createTransfer. Real money only moves once the user activates the rule themselves.
• Idempotent. Before creating an account or rule, list first and reuse anything already named for this loop, so re-running the skill doesn't duplicate.
• Confirm the numbers — they're case by case. Tax rate, cleaner rate, and reserve share differ per host. Offer the 30% / fixed / 15% defaults but never build until the host confirms all three.
• Group the set-asides. Tax %, cleaning fixed, and reserve % must share one groupIndex so each share is off the gross payout; the remainder sweep to Profit is a later group. Getting this wrong silently under-funds the reserve. See reference/rules.md.
• One incoming-trigger rule per account. The Payouts account can hold only one ON_FUNDS_TRANSFERRED rule — that's why the whole split is a single rule. On a re-run, update the existing rule rather than trying to add a second.
• Permissions. Verifying identity, connecting a bank, and issuing a card all need Writer/Admin on the Sequence account + approved KYC/KYB. If a deep-linked step is missing in the app, that's usually the cause — tell the user.