Analyst run

1import json
2import stripe_data
3 
4subs = stripe_data.subscriptions()
5 
6mrr_usd = 0.0
7customers = set()
8trialing_usd = 0.0
9canceled_count = 0
10mrr_count = 0
11 
12for s in subs:
13    status = s.get("status")
14    if status in ("active", "past_due"):
15        minor = stripe_data.monthly_amount(s)
16        usd = stripe_data.to_usd(minor, s["currency"])
17        mrr_usd += usd
18        customers.add(s["customer"])
19        mrr_count += 1
20    elif status == "trialing":
21        minor = stripe_data.monthly_amount(s)
22        trialing_usd += stripe_data.to_usd(minor, s["currency"])
23    elif status == "canceled":
24        canceled_count += 1
25 
26arr_usd = mrr_usd * 12
27logo_churn = canceled_count / (mrr_count + canceled_count) if (mrr_count + canceled_count) else 0
28 
29result = {
30    "answer": f"Current MRR is ${mrr_usd:,.2f} USD across {len(customers)} customers ({mrr_count} contributing subscriptions), with ARR of ${arr_usd:,.2f} and a trial pipeline of ${trialing_usd:,.2f}.",
31    "value": round(mrr_usd, 2),
32    "unit": "USD",
33    "table": [
34        {"metric": "MRR (USD)", "value": round(mrr_usd, 2)},
35        {"metric": "ARR (USD)", "value": round(arr_usd, 2)},
36        {"metric": "Customers (MRR)", "value": len(customers)},
37        {"metric": "MRR subscriptions", "value": mrr_count},
38        {"metric": "Trial pipeline (USD)", "value": round(trialing_usd, 2)},
39        {"metric": "Canceled subscriptions", "value": canceled_count},
40        {"metric": "Logo churn (current)", "value": round(logo_churn * 100, 2)},
41    ],
42    "method": "Summed monthly_amount (minor units, post-discount) over subscriptions with status active or past_due, converted each to USD via to_usd using the subscription currency, and aggregated.",
43}
44 
45print("RESULT: " + json.dumps(result))

1import json
2import stripe_data
3 
4# MRR-contributing subscription statuses
5MRR_STATUSES = {"active", "past_due"}
6 
7subs = stripe_data.subscriptions()
8 
9# Distinct customers with at least one MRR-contributing subscription
10paying_customers = set()
11for sub in subs:
12    if sub.get("status") in MRR_STATUSES:
13        cust = sub.get("customer")
14        if cust:
15            paying_customers.add(cust)
16 
17count = len(paying_customers)
18 
19result = {
20    "answer": f"We have {count} paying customers right now, defined as distinct customers with at least one active or past_due subscription.",
21    "value": count,
22    "unit": "customers",
23    "table": [],
24    "method": "Counted distinct customer IDs across all subscriptions whose status is 'active' or 'past_due' (the MRR-contributing statuses), per the MRR metric definition."
25}
26 
27print("RESULT: " + json.dumps(result))

1import json
2import stripe_data
3 
4# Build customer lookup by id
5customers = stripe_data.customers()
6cust_by_id = {c["id"]: c for c in customers}
7 
8# Get all subscriptions
9subs = stripe_data.subscriptions()
10 
11# MRR-contributing subscriptions: status active or past_due
12mrr_subs = [s for s in subs if s.get("status") in ("active", "past_due")]
13 
14# Sum MRR in USD by customer market
15mrr_by_market = {"top": 0.0, "emerging": 0.0, "unknown": 0.0}
16for s in mrr_subs:
17    cust = cust_by_id.get(s.get("customer"))
18    market = "unknown"
19    if cust:
20        market = cust.get("metadata", {}).get("market", "unknown")
21    minor = stripe_data.monthly_amount(s)
22    usd = stripe_data.to_usd(minor, s.get("currency"))
23    mrr_by_market[market] = mrr_by_market.get(market, 0.0) + usd
24 
25total_mrr = sum(mrr_by_market.values())
26emerging_mrr = mrr_by_market.get("emerging", 0.0)
27pct_emerging = (emerging_mrr / total_mrr * 100.0) if total_mrr > 0 else 0.0
28 
29table = [
30    {"market": k, "mrr_usd": round(v, 2)}
31    for k, v in sorted(mrr_by_market.items(), key=lambda x: -x[1])
32]
33 
34answer = (
35    f"Emerging-market customers account for {pct_emerging:.1f}% of total MRR "
36    f"(${emerging_mrr:,.0f} of ${total_mrr:,.0f})."
37)
38 
39result = {
40    "answer": answer,
41    "value": round(pct_emerging, 2),
42    "unit": "percent",
43    "table": table,
44    "method": (
45        "Summed monthly_amount (USD-converted) over active/past_due subscriptions, "
46        "grouped by customer metadata market, then computed emerging / total * 100."
47    ),
48}
49 
50print("RESULT: " + json.dumps(result))

1import stripe_data
2import json
3 
4subscriptions = stripe_data.subscriptions()
5 
6# Debug: count subscriptions by status
7status_counts = {}
8for sub in subscriptions:
9    status = sub["status"]
10    status_counts[status] = status_counts.get(status, 0) + 1
11 
12print("Subscription status counts:")
13for status, count in sorted(status_counts.items()):
14    print(f"  {status}: {count}")
15 
16# Group subscriptions by customer
17customer_subs = {}
18for sub in subscriptions:
19    cust_id = sub["customer"]
20    if cust_id not in customer_subs:
21        customer_subs[cust_id] = []
22    customer_subs[cust_id].append(sub)
23 
24# Classify customers:
25# - MRR-contributing: at least one active or past_due subscription
26# - Canceled (churned): at least one canceled subscription, no active/past_due
27mrr_customers = set()
28canceled_customers = set()
29 
30for cust_id, subs in customer_subs.items():
31    has_mrr = any(s["status"] in ("active", "past_due") for s in subs)
32    has_canceled = any(s["status"] == "canceled" for s in subs)
33    
34    if has_mrr:
35        mrr_customers.add(cust_id)
36    elif has_canceled:
37        canceled_customers.add(cust_id)
38 
39mrr_count = len(mrr_customers)
40canceled_count = len(canceled_customers)
41total = mrr_count + canceled_count
42 
43logo_churn = (canceled_count / total * 100) if total > 0 else 0
44 
45print(f"\nMRR-contributing customers: {mrr_count}")
46print(f"Canceled customers: {canceled_count}")
47print(f"Total (MRR + canceled): {total}")
48print(f"Logo churn: {logo_churn:.2f}%")
49 
50result = {
51    "answer": f"Our current logo churn rate is {logo_churn:.2f}%, based on {canceled_count} churned customers out of {total} total customers (MRR-contributing + churned).",
52    "value": round(logo_churn, 2),
53    "unit": "percent",
54    "table": [
55        {"metric": "MRR-contributing customers", "count": mrr_count},
56        {"metric": "Canceled customers", "count": canceled_count},
57        {"metric": "Total customers", "count": total},
58        {"metric": "Logo churn rate", "value": f"{logo_churn:.2f}%"}
59    ],
60    "method": "Counted distinct customers with at least one active or past_due subscription as MRR-contributing, and customers with only canceled subscriptions (no active/past_due) as churned; logo churn = churned / (MRR-contributing + churned) × 100."
61}
62 
63print(f"RESULT: {json.dumps(result)}")

1import json
2from collections import defaultdict
3import stripe_data
4 
5# Fixed FX rates (units of currency per 1 USD)
6FX = {
7    "usd": 1, "eur": 0.92, "gbp": 0.79, "cad": 1.37, "aud": 1.52,
8    "jpy": 150, "sgd": 1.34, "inr": 84, "brl": 5.4, "mxn": 18,
9    "aed": 3.67, "pln": 4, "thb": 35, "myr": 4.6, "zar": 18, "php": 57,
10}
11 
12# MRR-contributing statuses
13MRR_STATUSES = {"active", "past_due"}
14 
15def get_interval(item):
16    """Return billing interval string like 'monthly' or 'yearly'."""
17    recurring = item["price"].get("recurring", {})
18    interval = recurring.get("interval", "monthly")
19    interval_count = recurring.get("interval_count", 1)
20    if interval == "year":
21        return "yearly"
22    elif interval == "month":
23        return "monthly"
24    else:
25        return interval
26 
27def get_plan(sub):
28    """Return plan from metadata, default to 'unknown'."""
29    return sub.get("metadata", {}).get("plan", "unknown")
30 
31# Group MRR-contributing subscriptions by (plan, interval)
32archetypes = defaultdict(lambda: {"count": 0, "mrr_minor": 0})
33 
34for sub in stripe_data.subscriptions():
35    if sub["status"] not in MRR_STATUSES:
36        continue
37 
38    plan = get_plan(sub)
39    currency = sub["currency"]
40 
41    # Determine interval from first item (assume consistent within subscription)
42    items = sub.get("items", {}).get("data", [])
43    if not items:
44        continue
45    interval = get_interval(items[0])
46 
47    # Get monthly MRR in minor units (subscription currency)
48    mrr_minor = stripe_data.monthly_amount(sub)
49 
50    # Convert to USD
51    mrr_usd = stripe_data.to_usd(mrr_minor, currency)
52 
53    key = (plan, interval)
54    archetypes[key]["count"] += 1
55    archetypes[key]["mrr_minor"] += mrr_minor  # accumulate minor units before conversion
56    # Actually, we should accumulate USD since to_usd is per-subscription
57    # Let's redo: accumulate USD
58    # We'll fix below
59 
60# Redo properly: accumulate USD per archetype
61archetypes = defaultdict(lambda: {"count": 0, "mrr_usd": 0.0})
62 
63for sub in stripe_data.subscriptions():
64    if sub["status"] not in MRR_STATUSES:
65        continue
66 
67    plan = get_plan(sub)
68    currency = sub["currency"]
69 
70    items = sub.get("items", {}).get("data", [])
71    if not items:
72        continue
73    interval = get_interval(items[0])
74 
75    mrr_minor = stripe_data.monthly_amount(sub)
76    mrr_usd = stripe_data.to_usd(mrr_minor, currency)
77 
78    key = (plan, interval)
79    archetypes[key]["count"] += 1
80    archetypes[key]["mrr_usd"] += mrr_usd
81 
82# Build table
83table = []
84for (plan, interval), data in sorted(archetypes.items()):
85    table.append({
86        "plan": plan,
87        "interval": interval,
88        "subscriptions": data["count"],
89        "mrr_usd": round(data["mrr_usd"], 2),
90    })
91 
92num_archetypes = len(table)
93 
94answer = (
95    f"There are {num_archetypes} MRR-contributing subscription archetypes "
96    f"grouped by plan and billing interval. "
97    f"Combined MRR across all archetypes is "
98    f"{sum(row['mrr_usd'] for row in table):,.2f} USD."
99)
100 
101result = {
102    "answer": answer,
103    "value": num_archetypes,
104    "unit": "archetypes",
105    "table": table,
106    "method": (
107        "Iterated over all subscriptions, filtered to active/past_due statuses, "
108        "grouped by (plan metadata, billing interval from price.recurring), "
109        "summed monthly_amount converted to USD via to_usd for each archetype."
110    ),
111}
112 
113print("RESULT: " + json.dumps(result))