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

# Payments

export const PayoutEstimator = () => {
  const PT = "America/Los_Angeles";
  const QUICK_ZONES = [{
    label: "United States — Pacific (PT)",
    tz: "America/Los_Angeles"
  }, {
    label: "United States — Mountain (MT)",
    tz: "America/Denver"
  }, {
    label: "United States — Central (CT)",
    tz: "America/Chicago"
  }, {
    label: "United States — Eastern (ET)",
    tz: "America/New_York"
  }, {
    label: "Canada — Eastern",
    tz: "America/Toronto"
  }, {
    label: "Canada — Pacific",
    tz: "America/Vancouver"
  }, {
    label: "Mexico — Mexico City",
    tz: "America/Mexico_City"
  }, {
    label: "Brazil — São Paulo",
    tz: "America/Sao_Paulo"
  }, {
    label: "Argentina — Buenos Aires",
    tz: "America/Argentina/Buenos_Aires"
  }, {
    label: "United Kingdom — London",
    tz: "Europe/London"
  }, {
    label: "Ireland — Dublin",
    tz: "Europe/Dublin"
  }, {
    label: "Portugal — Lisbon",
    tz: "Europe/Lisbon"
  }, {
    label: "Central Europe (CET) — Berlin",
    tz: "Europe/Berlin"
  }, {
    label: "Central Europe (CET) — Paris",
    tz: "Europe/Paris"
  }, {
    label: "Eastern Europe — Athens",
    tz: "Europe/Athens"
  }, {
    label: "Turkey — Istanbul",
    tz: "Europe/Istanbul"
  }, {
    label: "Nigeria — Lagos (WAT)",
    tz: "Africa/Lagos"
  }, {
    label: "Egypt — Cairo",
    tz: "Africa/Cairo"
  }, {
    label: "Kenya — Nairobi (EAT)",
    tz: "Africa/Nairobi"
  }, {
    label: "South Africa — Johannesburg",
    tz: "Africa/Johannesburg"
  }, {
    label: "UAE — Dubai (GST)",
    tz: "Asia/Dubai"
  }, {
    label: "Pakistan — Karachi (PKT)",
    tz: "Asia/Karachi"
  }, {
    label: "India — IST",
    tz: "Asia/Kolkata"
  }, {
    label: "Bangladesh — Dhaka",
    tz: "Asia/Dhaka"
  }, {
    label: "Thailand — Bangkok",
    tz: "Asia/Bangkok"
  }, {
    label: "Indonesia — Jakarta",
    tz: "Asia/Jakarta"
  }, {
    label: "Vietnam — Ho Chi Minh City",
    tz: "Asia/Ho_Chi_Minh"
  }, {
    label: "Singapore",
    tz: "Asia/Singapore"
  }, {
    label: "Philippines — Manila (PHT)",
    tz: "Asia/Manila"
  }, {
    label: "China — Shanghai (CST)",
    tz: "Asia/Shanghai"
  }, {
    label: "Japan — Tokyo (JST)",
    tz: "Asia/Tokyo"
  }, {
    label: "South Korea — Seoul (KST)",
    tz: "Asia/Seoul"
  }, {
    label: "Australia — Sydney (AEST)",
    tz: "Australia/Sydney"
  }, {
    label: "New Zealand — Auckland",
    tz: "Pacific/Auckland"
  }, {
    label: "UTC",
    tz: "UTC"
  }];
  const FALLBACK_ZONES = QUICK_ZONES.map(z => z.tz);
  const validTz = s => {
    if (!s || typeof s !== "string") return false;
    try {
      new Intl.DateTimeFormat("en-US", {
        timeZone: s
      });
      return true;
    } catch {
      return false;
    }
  };
  const allIanaZones = () => {
    try {
      if (typeof Intl.supportedValuesOf === "function") return Intl.supportedValuesOf("timeZone");
    } catch {}
    return FALLBACK_ZONES;
  };
  const gmtLabel = tz => {
    try {
      const part = new Intl.DateTimeFormat("en-US", {
        timeZone: tz,
        timeZoneName: "shortOffset"
      }).formatToParts(new Date()).find(p => p.type === "timeZoneName");
      return part ? part.value : "";
    } catch {
      return "";
    }
  };
  const humanizeZone = id => id.replace(/_/g, " ").replace(/\//g, " / ");
  const tzOffsetMs = (date, tz) => {
    const dtf = new Intl.DateTimeFormat("en-US", {
      timeZone: tz,
      hour12: false,
      year: "numeric",
      month: "2-digit",
      day: "2-digit",
      hour: "2-digit",
      minute: "2-digit",
      second: "2-digit"
    });
    const p = {};
    for (const part of dtf.formatToParts(date)) p[part.type] = part.value;
    const hour = p.hour === "24" ? 0 : Number(p.hour);
    const asUTC = Date.UTC(Number(p.year), Number(p.month) - 1, Number(p.day), hour, Number(p.minute), Number(p.second));
    return asUTC - date.getTime();
  };
  const wallToInstant = (wallStr, tz) => {
    const naive = new Date(wallStr + ":00Z");
    let offset = tzOffsetMs(naive, tz);
    let instant = new Date(naive.getTime() - offset);
    const offset2 = tzOffsetMs(instant, tz);
    if (offset2 !== offset) instant = new Date(naive.getTime() - offset2);
    return instant;
  };
  const civilOf = (instant, tz) => {
    const dtf = new Intl.DateTimeFormat("en-CA", {
      timeZone: tz,
      year: "numeric",
      month: "2-digit",
      day: "2-digit",
      weekday: "short"
    });
    const p = {};
    for (const part of dtf.formatToParts(instant)) p[part.type] = part.value;
    const map = {
      Sun: 0,
      Mon: 1,
      Tue: 2,
      Wed: 3,
      Thu: 4,
      Fri: 5,
      Sat: 6
    };
    return {
      y: Number(p.year),
      m: Number(p.month),
      d: Number(p.day),
      dow: map[p.weekday]
    };
  };
  const addDays = (civil, n) => {
    const dt = new Date(Date.UTC(civil.y, civil.m - 1, civil.d));
    dt.setUTCDate(dt.getUTCDate() + n);
    return {
      y: dt.getUTCFullYear(),
      m: dt.getUTCMonth() + 1,
      d: dt.getUTCDate(),
      dow: dt.getUTCDay()
    };
  };
  const mondayOf = civil => {
    const back = civil.dow === 0 ? 6 : civil.dow - 1;
    return addDays(civil, -back);
  };
  const addBusinessDays = (civil, n) => {
    let c = civil, added = 0;
    while (added < n) {
      c = addDays(c, 1);
      if (c.dow !== 0 && c.dow !== 6) added++;
    }
    return c;
  };
  const civilToISO = civil => `${civil.y}-${String(civil.m).padStart(2, "0")}-${String(civil.d).padStart(2, "0")}`;
  const fmtCivil = civil => {
    const dt = new Date(Date.UTC(civil.y, civil.m - 1, civil.d, 12));
    return dt.toLocaleDateString("en-US", {
      timeZone: "UTC",
      weekday: "short",
      month: "short",
      day: "numeric"
    });
  };
  const fmtInstant = (instant, tz, withTime = true) => instant.toLocaleString("en-US", {
    timeZone: tz,
    weekday: "short",
    month: "short",
    day: "numeric",
    ...withTime ? {
      hour: "numeric",
      minute: "2-digit",
      hour12: true
    } : {}
  });
  const nowLocalInput = () => {
    const n = new Date();
    const pad = x => String(x).padStart(2, "0");
    return `${n.getFullYear()}-${pad(n.getMonth() + 1)}-${pad(n.getDate())}T${pad(n.getHours())}:${pad(n.getMinutes())}`;
  };
  const [rate, setRate] = React.useState("");
  const [hours, setHours] = React.useState("");
  const [tz, setTz] = React.useState(PT);
  const [tzMode, setTzMode] = React.useState("list");
  const [tzInput, setTzInput] = React.useState(PT);
  const [logTime, setLogTime] = React.useState(nowLocalInput());
  const [firstPayout, setFirstPayout] = React.useState(false);
  const allZones = React.useMemo(() => allIanaZones().map(id => ({
    id,
    label: humanizeZone(id),
    gmt: gmtLabel(id)
  })), []);
  const selectOptions = React.useMemo(() => {
    const opts = [...QUICK_ZONES];
    if (!opts.some(o => o.tz === tz)) {
      const g = gmtLabel(tz);
      opts.unshift({
        label: `${humanizeZone(tz)}${g ? " · " + g : ""}`,
        tz
      });
    }
    return opts;
  }, [tz]);
  const manualInvalid = tzMode === "manual" && tzInput.trim() !== "" && !validTz(tzInput.trim());
  const result = React.useMemo(() => {
    if (!logTime) return null;
    const logInstant = wallToInstant(logTime, tz);
    const ptCivil = civilOf(logInstant, PT);
    const monday = mondayOf(ptCivil);
    const sunday = addDays(monday, 6);
    const cutoffInstant = wallToInstant(`${civilToISO(sunday)}T23:59`, PT);
    const release = addDays(sunday, 5);
    const bankBase = firstPayout ? addDays(release, 7) : release;
    const bankLow = addBusinessDays(bankBase, 2);
    const bankHigh = addBusinessDays(bankBase, 3);
    const r = parseFloat(rate), h = parseFloat(hours);
    const gross = isFinite(r) && isFinite(h) && r >= 0 && h >= 0 ? r * h : null;
    return {
      logInstant,
      monday,
      sunday,
      cutoffInstant,
      release,
      bankLow,
      bankHigh,
      gross
    };
  }, [rate, hours, tz, logTime, firstPayout]);
  const C = {
    navy: "#15192b",
    ink: "#23283c",
    muted: "#8a8678",
    label: "#6f6a5c",
    line: "#e7e3d8",
    cream: "#f6f3ec",
    creamLine: "#e3ddcd",
    paper: "#fffdf8",
    warn: "#9a5b2e"
  };
  const SERIF = '"Iowan Old Style", "Palatino Linotype", Palatino, Georgia, "Times New Roman", serif';
  const SANS = 'ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, Helvetica, Arial, sans-serif';
  const card = {
    border: `1px solid ${C.line}`,
    borderRadius: 18,
    padding: 28,
    background: C.paper,
    fontFamily: SANS,
    color: C.ink,
    maxWidth: 760
  };
  const eyebrow = {
    fontFamily: SERIF,
    fontSize: 12,
    fontWeight: 700,
    letterSpacing: 1.2,
    textTransform: "uppercase",
    color: C.label
  };
  const labelStyle = {
    display: "block",
    fontFamily: SANS,
    fontSize: 13,
    fontWeight: 600,
    color: C.navy,
    marginBottom: 6
  };
  const hint = {
    fontSize: 12,
    color: C.muted,
    marginTop: 6,
    fontFamily: SANS
  };
  const linkBtn = {
    background: "none",
    border: "none",
    padding: 0,
    marginTop: 6,
    color: C.navy,
    fontFamily: SANS,
    fontSize: 12,
    fontWeight: 600,
    textDecoration: "underline",
    textUnderlineOffset: 2,
    cursor: "pointer"
  };
  const input = {
    width: "100%",
    boxSizing: "border-box",
    padding: "11px 13px",
    borderRadius: 10,
    border: `1px solid ${C.line}`,
    fontSize: 15,
    color: C.ink,
    background: "#fff",
    outline: "none",
    fontFamily: SANS
  };
  const Stage = ({kicker, big, small, underline, last}) => <div style={{
    flex: "1 1 0",
    minWidth: 132,
    position: "relative"
  }}>
      <div style={{
    display: "flex",
    alignItems: "center",
    marginBottom: 12
  }}>
        <span style={{
    width: 9,
    height: 9,
    borderRadius: "50%",
    background: C.navy,
    flex: "0 0 auto"
  }} />
        {!last && <span style={{
    flex: 1,
    height: 1,
    background: C.creamLine,
    marginLeft: 6
  }} />}
      </div>
      <div style={{
    ...eyebrow,
    fontSize: 10.5,
    marginBottom: 5
  }}>{kicker}</div>
      <div style={{
    fontFamily: SERIF,
    fontSize: 18,
    fontWeight: 700,
    color: C.navy,
    lineHeight: 1.2,
    textDecoration: underline ? "underline" : "none",
    textUnderlineOffset: 3,
    textDecorationThickness: "from-font"
  }}>{big}</div>
      {small && <div style={{
    fontFamily: SANS,
    fontSize: 12,
    color: C.muted,
    marginTop: 4,
    lineHeight: 1.35
  }}>{small}</div>}
    </div>;
  const sameDay = result && result.bankLow.y === result.bankHigh.y && result.bankLow.m === result.bankHigh.m && result.bankLow.d === result.bankHigh.d;
  return <div style={card}>
      <div style={{
    ...eyebrow,
    marginBottom: 8
  }}>AfterQuery · Weekly payout</div>
      <h3 style={{
    margin: "0 0 8px",
    fontFamily: SERIF,
    fontSize: 26,
    fontWeight: 700,
    color: C.navy
  }}>
        Estimate your hourly contract payout
      </h3>
      <p style={{
    margin: "0 0 24px",
    fontSize: 14,
    color: C.muted,
    lineHeight: 1.55,
    fontFamily: SANS
  }}>
        Enter your rate and approved hours, pick your timezone, and choose when you logged
        the work. We translate the Sunday cutoff into your local time and show the full
        journey of your money — through to the day it lands in your bank.
      </p>

      <div style={{
    display: "grid",
    gridTemplateColumns: "1fr 1fr",
    gap: 16,
    marginBottom: 16
  }}>
        <div>
          <label style={labelStyle}>Hourly rate (USD)</label>
          <input style={input} type="number" min="0" step="0.01" placeholder="e.g. 30.00" value={rate} onChange={e => setRate(e.target.value)} />
          <div style={hint}>From your AfterQuery contract</div>
        </div>
        <div>
          <label style={labelStyle}>Approved hours this week</label>
          <input style={input} type="number" min="0" step="0.25" placeholder="e.g. 20" value={hours} onChange={e => setHours(e.target.value)} />
          <div style={hint}>Use approved hours, not just logged — pay is based on approved work</div>
        </div>
      </div>

      <div style={{
    display: "grid",
    gridTemplateColumns: "1fr 1fr",
    gap: 16,
    marginBottom: 16
  }}>
        <div>
          <label style={labelStyle}>Country / timezone</label>
          {tzMode === "list" ? <>
              <select style={{
    ...input,
    appearance: "auto"
  }} value={tz} onChange={e => setTz(e.target.value)}>
                {selectOptions.map(t => <option key={t.tz} value={t.tz}>{t.label}</option>)}
              </select>
              <button type="button" style={linkBtn} onClick={() => {
    setTzInput(tz);
    setTzMode("manual");
  }}>
                Don't see your timezone? Enter it manually
              </button>
            </> : <>
              <input style={{
    ...input,
    borderColor: manualInvalid ? C.warn : C.line
  }} type="text" list="aq-tz-list" placeholder="Start typing, e.g. Europe/Madrid" value={tzInput} onChange={e => {
    const v = e.target.value;
    setTzInput(v);
    if (validTz(v.trim())) setTz(v.trim());
  }} />
              <datalist id="aq-tz-list">
                {allZones.map(z => <option key={z.id} value={z.id}>{z.label}{z.gmt ? " · " + z.gmt : ""}</option>)}
              </datalist>
              {manualInvalid ? <div style={{
    ...hint,
    color: C.warn
  }}>Not a recognized timezone — pick one from the suggestions.</div> : <div style={hint}>Type any IANA zone or choose from the full list.</div>}
              <button type="button" style={linkBtn} onClick={() => {
    if (!validTz(tzInput.trim())) setTz(PT);
    setTzMode("list");
  }}>
                Choose from the list instead
              </button>
            </>}
        </div>

        <div>
          <label style={labelStyle}>When did you log the work? (your local time)</label>
          <div style={{
    display: "flex",
    gap: 8
  }}>
            <input style={{
    ...input,
    flex: 1
  }} type="datetime-local" value={logTime} onChange={e => setLogTime(e.target.value)} />
            <button type="button" onClick={() => setLogTime(nowLocalInput())} style={{
    border: `1px solid ${C.line}`,
    background: "#fff",
    color: C.navy,
    borderRadius: 10,
    padding: "0 14px",
    fontSize: 13,
    fontWeight: 600,
    cursor: "pointer",
    whiteSpace: "nowrap",
    fontFamily: SANS
  }}>
              Now
            </button>
          </div>
          <div style={hint}>Type or pick a date and time — late-night work can land in a different week</div>
        </div>
      </div>

      <label style={{
    display: "flex",
    alignItems: "center",
    gap: 10,
    fontSize: 14,
    color: C.ink,
    marginBottom: 24,
    cursor: "pointer",
    fontFamily: SANS
  }}>
        <input type="checkbox" checked={firstPayout} onChange={e => setFirstPayout(e.target.checked)} style={{
    width: 16,
    height: 16,
    accentColor: C.navy
  }} />
        This is my first payout{" "}
        <span style={{
    color: C.muted
  }}>(Stripe holds your first-ever payout 7 days before sending)</span>
      </label>

      <div style={{
    background: C.cream,
    border: `1px solid ${C.creamLine}`,
    borderRadius: 14,
    padding: "22px 24px",
    marginBottom: 16
  }}>
        <div style={{
    ...eyebrow,
    marginBottom: 6
  }}>Estimated gross pay</div>
        <div style={{
    fontFamily: SERIF,
    fontSize: 46,
    fontWeight: 700,
    color: C.navy,
    lineHeight: 1
  }}>
          {result && result.gross != null ? result.gross.toLocaleString("en-US", {
    style: "currency",
    currency: "USD"
  }) : "$0.00"}
        </div>
        <div style={{
    fontFamily: SANS,
    fontSize: 13,
    color: C.muted,
    marginTop: 6
  }}>
          {result && result.gross != null ? "Gross only — before any taxes or deductions" : "Enter your rate and approved hours to see your payout and pay dates"}
        </div>
      </div>

      <div style={{
    background: C.cream,
    border: `1px solid ${C.creamLine}`,
    borderRadius: 14,
    padding: "22px 24px"
  }}>
        <div style={{
    ...eyebrow,
    marginBottom: 18
  }}>The journey of your pay</div>
        <div style={{
    display: "flex",
    gap: 14,
    flexWrap: "wrap"
  }}>
          {result ? <>
              <Stage kicker="Now" big={fmtCivil(civilOf(result.logInstant, tz))} small={fmtInstant(result.logInstant, tz).split(", ").slice(-1)[0] + " your time"} />
              <Stage kicker="Week cutoff" big={fmtCivil(result.sunday)} small={`${fmtInstant(result.cutoffInstant, tz)} your time · Sun 11:59 PM PT`} />
              <Stage kicker="Released" big={fmtCivil(result.release)} small="Friday · AfterQuery sends it" />
              <Stage last kicker="In your bank" underline big={sameDay ? fmtCivil(result.bankLow) : `${fmtCivil(result.bankLow)} – ${fmtCivil(result.bankHigh)}`} small={firstPayout ? "incl. 7-day first-payout hold" : "2–3 business days via Stripe"} />
            </> : <div style={{
    fontFamily: SANS,
    fontSize: 13,
    color: C.muted
  }}>
              Pick a log time and timezone to see your pay dates.
            </div>}
        </div>
      </div>

      <p style={{
    fontFamily: SANS,
    fontSize: 12,
    color: C.muted,
    lineHeight: 1.6,
    marginTop: 16,
    marginBottom: 0
  }}>
        Estimates only. Pay covers approved work, so unapproved hours may shift to a later
        week. Final amounts and dates are set by your contract and our payments system.
        Payouts are released every Friday by 11:59 p.m. PT; bank arrival depends on your bank.
      </p>
    </div>;
};

Setting up your payment correctly is how you get paid on time for your work. This guide walks you through setup and explains how and when payments are made.

## Quick estimator — when will I get paid?

Estimate your gross pay for the week and find the exact Friday we'll pay you, including the 7-day hold on your first payout.

<PayoutEstimator />

## Payment Method

We pay everyone through **Stripe**. There is one method, and it goes straight to your bank account.

* Processing: Paid every Friday for the prior week's approved work
* Fees: No fees from AfterQuery
* Requirements: A bank account in your own legal name, in a Stripe-supported country
* Cards: Not supported. Stripe pays to bank accounts only

Coming later: We plan to add Wise so we can pay people in countries Stripe doesn't reach. Wise is not available yet, so Stripe is the only method right now.

## Before You Start

Have these ready so you don't get stuck partway through:

* A bank account in your own legal name, in a supported country. Joint accounts, business accounts you don't own, and accounts in someone else's name will be rejected
* A government ID. If you're in the US, you'll also need your SSN. Stripe requires this by law and we can't waive it
* A phone that can get text messages, for two-factor login

Your bank account must be in the same country as your registered location. If they don't match, Stripe holds your payout and starts a manual review, which is slow and delays your pay. And use the exact same legal name across your offer, your Stripe account, and your bank account, since a name mismatch causes the same problem.

## Setup Process

<Info>
  Stripe is how AfterQuery pays contributors whose bank account is in a supported country. Follow the steps below the first time you accept an offer.
</Info>

<Steps>
  <Step title="Click 'Set Up Payments' when accepting your offer">
    When you accept your offer, select Set Up Payments. You can also open it anytime from your Earnings dashboard. This launches the Stripe setup flow.

    <Frame>
      <img src="https://mintcdn.com/afterqueryexperts/xxtxvWKWyqHEDXim/images/Screenshot-2026-06-22-at-1.36.20-PM.png?fit=max&auto=format&n=xxtxvWKWyqHEDXim&q=85&s=128c3c006558ba36ca9756e728a89e89" alt="Screenshot 2026 06 22 At 1 36 20 PM" width="1336" height="178" data-path="images/Screenshot-2026-06-22-at-1.36.20-PM.png" />
    </Frame>
  </Step>

  <Step title="Complete the Stripe setup flow">
    Follow Stripe's prompts carefully. Identity verification, bank account details, and tax information are all required. If you get stuck, Stripe's help center is at support.stripe.com/express.
  </Step>

  <Step title="Return to your offer">
    Once Stripe confirms your setup, you'll be returned to the offer flow to finish accepting your offer. Your payouts are now automatic.
  </Step>

  <Step title="Note the first-payout holding period">
    Stripe requires a 7-day holding period on your first payout. This is a Stripe rule and AfterQuery cannot override it. Every payout after the first follows the normal Friday schedule.
  </Step>
</Steps>

## When You Get Paid

* Pay-day: Every Friday by 11:59 p.m. PT
* Pay period: Monday to Sunday
* How it works: When a week ends, your work is reviewed and approved, then paid out the following Friday
* The gap: That review step is why there's a short wait between finishing work and getting paid
* Arrival: After Stripe sends the money, your bank usually takes a few business days. We can't speed this up
* Tracking: Check any payout's status in your Stripe dashboard or your Earnings dashboard

## Managing Your Payments

You control your own Stripe account. We can't see or change your Stripe details for you.

* Change your bank account: In Stripe, go to Settings > Payouts and update it. Future payouts use the new account
* Reset your Stripe connection: In your Earnings dashboard, choose Reset Payment Setup. This permanently deletes your Stripe data and history, so only do it when you have no payment in transit and no Stripe balance
* Forgot your password: Reset it from Stripe's login page
* Change your Stripe email: Contact Stripe Support directly

## Common Questions

<AccordionGroup>
  <Accordion title="What currency will I be paid in?">
    Rates are in USD. Stripe converts your earnings into your local currency at payout.
  </Accordion>

  <Accordion title="Can I get paid in USD if I live outside the US?">
    No. Since AfterQuery is based in the US, payouts outside the US go out in your local currency.
  </Accordion>

  <Accordion title="Why didn't my latest work show up in this week's payout?">
    Each Friday pays the week that already closed and was approved. Work from the current week is paid the following Friday.
  </Accordion>

  <Accordion title="Can AfterQuery pause, delay, batch, or speed up my payouts?">
    No. Payouts run automatically every Friday. Once Stripe sends one, the timing is up to the banks.
  </Accordion>

  <Accordion title="My payout is on hold or being manually reviewed. Why?">
    This usually happens when your registered location and your bank account country don't match. Stripe flags it, holds the funds, and runs a manual check that takes a while and creates back and forth between you, us, and Stripe. Make sure your bank account is in the same country as the location on your profile.
  </Accordion>

  <Accordion title="My country isn't supported. Can I use someone else's account in a supported country?">
    No. Payouts can only go to a bank account in your own legal name in a supported country.
  </Accordion>

  <Accordion title="Stripe wants my SSN, ID, and bank details. Can I skip this?">
    No. Stripe requires identity verification to pay you. You can't finish setup without it.
  </Accordion>

  <Accordion title="My ID verification keeps failing. What do I do?">
    This usually happens when a personal name is entered in a company-name field. Contact Stripe Support and they can do a manual review.
  </Accordion>

  <Accordion title="Stripe wants a routing number or sort code that doesn't exist in my country.">
    Stripe picks the required fields based on your country, and the label can be generic. Ask your bank for the exact value Stripe is asking for. These codes often aren't in your banking app.
  </Accordion>

  <Accordion title="Why can't I add a foreign bank account to my Stripe profile?">
    Stripe only accepts a local bank account in the same country as your Stripe account.
  </Accordion>

  <Accordion title="I changed my bank details after a payout was sent. Where does it go?">
    Payouts already sent go to the old account. Future payouts use the new one.
  </Accordion>

  <Accordion title="What if a payout went to the wrong bank details?">
    It can't be cancelled. The bank rejects it, the money returns to your Stripe balance, and Stripe retries with your updated details. This takes about 10 to 15 business days and can't be rushed.
  </Accordion>

  <Accordion title="Stripe says my account is on hold or paused.">
    Holds come from Stripe, not us, so we can't lift them. Log in to Stripe, clear any pending actions, and contact Stripe Support if it stays. Payouts resume automatically once it's cleared.
  </Accordion>

  <Accordion title="My bank needs a reference number to find the payout. Where is it?">
    Stripe creates a payout trace ID once a payout shows as Paid. It's in your Stripe dashboard under Payout Details.
  </Accordion>

  <Accordion title="The form asks for business details, but I'm an individual.">
    Optional fields can be left blank. For any required business field, treat yourself as a sole proprietor and use your personal details.
  </Accordion>
</AccordionGroup>

## Need Help?

Email [support@afterquery.com](mailto:support@afterquery.com) with your full name and the email you log in with, and we'll help.
