Skip to content

Marketplace

startup_valuation.marketplace

Marketplace valuation methods.

Chapter 11: Industry-Specific Valuation Frameworks — Marketplaces

Classes

Functions

gmv(transaction_values)

Calculate Gross Merchandise Value.

Formula: GMV = Σ Transaction Valueᵢ

Source code in src/startup_valuation/marketplace.py 
11
12
13
14
15
16
17
18
19
20
21
def gmv(transaction_values: list[float]) -> ValuationResult:
    """Calculate Gross Merchandise Value.

    Formula: GMV = Σ Transaction Valueᵢ
    """
    return ValuationResult(
        value=sum(transaction_values),
        method="GMV",
        inputs={"transaction_count": len(transaction_values)},
        chapter="11",
    )

take_rate(revenue, gmv)

Calculate marketplace take rate.

Formula: Take Rate = Revenue / GMV

Example

result = take_rate(2_900_000_000, 24_700_000_000) round(result.value, 4) 0.1174

Source code in src/startup_valuation/marketplace.py 
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
def take_rate(revenue: float, gmv: float) -> ValuationResult:
    """Calculate marketplace take rate.

    Formula: Take Rate = Revenue / GMV

    Example:
        >>> result = take_rate(2_900_000_000, 24_700_000_000)
        >>> round(result.value, 4)
        0.1174
    """
    if gmv <= 0:
        raise ValueError("gmv must be positive")
    return ValuationResult(
        value=revenue / gmv,
        method="Take Rate",
        inputs={"revenue": revenue, "gmv": gmv},
        chapter="11",
    )

liquidity(successful_transactions, total_attempts)

Calculate marketplace liquidity.

Formula: Liquidity = Successful Transactions / Total Attempts

Source code in src/startup_valuation/marketplace.py 
44
45
46
47
48
49
50
51
52
53
54
55
56
def liquidity(successful_transactions: int, total_attempts: int) -> ValuationResult:
    """Calculate marketplace liquidity.

    Formula: Liquidity = Successful Transactions / Total Attempts
    """
    if total_attempts <= 0:
        raise ValueError("total_attempts must be positive")
    return ValuationResult(
        value=successful_transactions / total_attempts,
        method="Liquidity",
        inputs={"successful_transactions": successful_transactions, "total_attempts": total_attempts},
        chapter="11",
    )

gmv_multiple_valuation(gmv, multiple)

Value a marketplace using GMV multiple.

Formula: Valuation = GMV × Multiple

Example

result = gmv_multiple_valuation(24_700_000_000, 2.4) result.value / 1_000_000_000 59.28

Source code in src/startup_valuation/marketplace.py 
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
def gmv_multiple_valuation(gmv: float, multiple: float) -> ValuationResult:
    """Value a marketplace using GMV multiple.

    Formula: Valuation = GMV × Multiple

    Example:
        >>> result = gmv_multiple_valuation(24_700_000_000, 2.4)
        >>> result.value / 1_000_000_000
        59.28
    """
    return ValuationResult(
        value=gmv * multiple,
        method="GMV Multiple Valuation",
        inputs={"gmv": gmv, "multiple": multiple},
        assumptions=["Multiple depends on marketplace maturity and growth"],
        chapter="11",
    )

network_value(active_users, k=1.0, alpha=1.3)

Calculate network value using modified Metcalfe's Law.

Formula: Valuation = k × Active Users^α

Parameters:

Name Type Description Default
active_users float

Number of active users.

 required
k float

Value per connection constant.

 1.0
alpha float

Network effect exponent (1.2-1.5 empirical).

 1.3

Returns:

Type Description
ValuationResult

ValuationResult with network value.
Source code in src/startup_valuation/marketplace.py 
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
def network_value(active_users: float, k: float = 1.0, alpha: float = 1.3) -> ValuationResult:
    """Calculate network value using modified Metcalfe's Law.

    Formula: Valuation = k × Active Users^α

    Args:
        active_users: Number of active users.
        k: Value per connection constant.
        alpha: Network effect exponent (1.2-1.5 empirical).

    Returns:
        ValuationResult with network value.
    """
    return ValuationResult(
        value=k * (active_users ** alpha),
        method="Network Value",
        inputs={"active_users": active_users, "k": k, "alpha": alpha},
        assumptions=[f"Network effect exponent α={alpha}"],
        chapter="11",
    )

buyer_retention(buyers_period_1, buyers_repeat)

Calculate marketplace buyer retention rate.

Formula: Buyer Retention = Repeat Buyers / Buyers in Period 1

Parameters:

Name Type Description Default
buyers_period_1 int

Number of buyers in period 1.

 required
buyers_repeat int

Number of buyers who returned in period 2.

 required

Returns:

Type Description
ValuationResult

ValuationResult with buyer retention rate.
Example

result = buyer_retention(10000, 3500) result.value 0.35

Source code in src/startup_valuation/marketplace.py 
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
def buyer_retention(
    buyers_period_1: int,
    buyers_repeat: int,
) -> ValuationResult:
    """Calculate marketplace buyer retention rate.

    Formula: Buyer Retention = Repeat Buyers / Buyers in Period 1

    Args:
        buyers_period_1: Number of buyers in period 1.
        buyers_repeat: Number of buyers who returned in period 2.

    Returns:
        ValuationResult with buyer retention rate.

    Example:
        >>> result = buyer_retention(10000, 3500)
        >>> result.value
        0.35
    """
    if buyers_period_1 <= 0:
        raise ValueError("buyers_period_1 must be positive")
    return ValuationResult(
        value=buyers_repeat / buyers_period_1,
        method="Buyer Retention",
        inputs={"buyers_period_1": buyers_period_1, "buyers_repeat": buyers_repeat},
        assumptions=["Period 1 and Period 2 are comparable time windows"],
        chapter="11",
    )

network_density(active_buyers, active_sellers, total_users)

Calculate marketplace network density.

Formula: Density = Actual Connections / Potential Connections where Actual = buyers × sellers, Potential = total × (total - 1) / 2

Parameters:

Name Type Description Default
active_buyers int

Number of active buyers.

 required
active_sellers int

Number of active sellers.

 required
total_users int

Total number of users.

 required

Returns:

Type Description
ValuationResult

ValuationResult with network density ratio.
Example

result = network_density(5000, 3000, 10000) round(result.value, 6) 0.0003

Source code in src/startup_valuation/marketplace.py 
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
def network_density(
    active_buyers: int,
    active_sellers: int,
    total_users: int,
) -> ValuationResult:
    """Calculate marketplace network density.

    Formula: Density = Actual Connections / Potential Connections
    where Actual = buyers × sellers, Potential = total × (total - 1) / 2

    Args:
        active_buyers: Number of active buyers.
        active_sellers: Number of active sellers.
        total_users: Total number of users.

    Returns:
        ValuationResult with network density ratio.

    Example:
        >>> result = network_density(5000, 3000, 10000)
        >>> round(result.value, 6)
        0.0003
    """
    if total_users <= 1:
        raise ValueError("total_users must be greater than 1")
    actual = active_buyers * active_sellers
    potential = total_users * (total_users - 1) / 2
    return ValuationResult(
        value=actual / potential,
        method="Network Density",
        inputs={
            "active_buyers": active_buyers,
            "active_sellers": active_sellers,
            "total_users": total_users,
        },
        assumptions=["Network density measures marketplace liquidity potential"],
        chapter="11",
    )