# Get Transfer Limits
> Source: /api-reference/members/me/transfers/get-limits
> Get current transfer limits including tier defaults, overrides, and usage
> Endpoint: GET /members/me/transfers/limits

## Overview [#overview]

Returns the current member's transfer limits including tier defaults, member-specific overrides, and current usage statistics. Use this endpoint to verify transfer limits before attempting transfers and to display available transfer capacity to users.

## Authentication [#authentication]

Requires a valid Clerk JWT token in the Authorization header.

<RequestExample>

```bash cURL
curl -X GET "http://localhost:3000/v1/members/me/transfers/limits" \
  -H "Authorization: Bearer YOUR_CLERK_JWT"
```

```typescript TypeScript
const response = await fetch('http://localhost:3000/v1/members/me/transfers/limits', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer YOUR_CLERK_JWT'
  }
});

const limits = await response.json();
```

</RequestExample>

## Response [#response]

<ResponseField name="perTransferMax" type="number" required>
  Maximum points allowed per single transfer
</ResponseField>

<ResponseField name="dailyLimit" type="number" required>
  Maximum points that can be transferred per day
</ResponseField>

<ResponseField name="monthlyLimit" type="number" required>
  Maximum points that can be transferred per month
</ResponseField>

<ResponseField name="minimumTransfer" type="number" required>
  Minimum points required for any transfer
</ResponseField>

<ResponseField name="dailyUsed" type="number" required>
  Points already transferred today
</ResponseField>

<ResponseField name="dailyRemaining" type="number" required>
  Remaining points available for transfer today
</ResponseField>

<ResponseField name="monthlyUsed" type="number" required>
  Points already transferred this month
</ResponseField>

<ResponseField name="monthlyRemaining" type="number" required>
  Remaining points available for transfer this month
</ResponseField>

<ResponseExample>

```json 200 Response - Standard Tier
{
  "perTransferMax": 50000,
  "dailyLimit": 100000,
  "monthlyLimit": 500000,
  "minimumTransfer": 100,
  "dailyUsed": 5000,
  "dailyRemaining": 95000,
  "monthlyUsed": 25000,
  "monthlyRemaining": 475000
}
```

```json 200 Response - Premium Tier
{
  "perTransferMax": 100000,
  "dailyLimit": 250000,
  "monthlyLimit": 1000000,
  "minimumTransfer": 50,
  "dailyUsed": 15000,
  "dailyRemaining": 235000,
  "monthlyUsed": 85000,
  "monthlyRemaining": 915000
}
```

```json 200 Response - Near Limits
{
  "perTransferMax": 50000,
  "dailyLimit": 100000,
  "monthlyLimit": 500000,
  "minimumTransfer": 100,
  "dailyUsed": 95000,
  "dailyRemaining": 5000,
  "monthlyUsed": 475000,
  "monthlyRemaining": 25000
}
```

</ResponseExample>

## Limit Types [#limit-types]

### Per Transfer Maximum [#per-transfer-maximum]
- **Purpose**: Maximum points in a single transfer
- **Typical Values**: 50,000 - 100,000 points
- **Use Case**: Prevent large single transfers
- **Override**: Can be increased for VIP members

### Daily Limit [#daily-limit]
- **Purpose**: Maximum points transferred per calendar day
- **Reset**: Midnight UTC
- **Typical Values**: 100,000 - 250,000 points
- **Cumulative**: Includes all transfers (direct + pending)

### Monthly Limit [#monthly-limit]
- **Purpose**: Maximum points transferred per calendar month
- **Reset**: First day of month at midnight UTC
- **Typical Values**: 500,000 - 1,000,000 points
- **Rollover**: No rollover of unused limits

### Minimum Transfer [#minimum-transfer]
- **Purpose**: Smallest transfer amount allowed
- **Typical Values**: 50 - 100 points
- **Reason**: Prevent spam/abuse of small transfers

## Tier-Based Limits [#tier-based-limits]

### Standard Tier [#standard-tier]
```json
{
  "perTransferMax": 50000,
  "dailyLimit": 100000,
  "monthlyLimit": 500000,
  "minimumTransfer": 100
}
```

### Premium Tier [#premium-tier]
```json
{
  "perTransferMax": 75000,
  "dailyLimit": 200000,
  "monthlyLimit": 750000,
  "minimumTransfer": 75
}
```

### VIP Tier [#vip-tier]
```json
{
  "perTransferMax": 100000,
  "dailyLimit": 250000,
  "monthlyLimit": 1000000,
  "minimumTransfer": 50
}
```

## Usage Calculations [#usage-calculations]

### Daily Usage [#daily-usage]
- **Tracks**: All transfers within current calendar day (UTC)
- **Includes**: Direct transfers + pending transfers created
- **Resets**: Daily at midnight UTC
- **Calculation**: `dailyRemaining = dailyLimit - dailyUsed`

### Monthly Usage [#monthly-usage]
- **Tracks**: All transfers within current calendar month (UTC)
- **Includes**: Direct transfers + pending transfers created
- **Resets**: First day of month at midnight UTC
- **Calculation**: `monthlyRemaining = monthlyLimit - monthlyUsed`

## Member Overrides [#member-overrides]

### Custom Limits [#custom-limits]
- **VIP Members**: May have higher limits
- **Business Accounts**: Custom enterprise limits
- **Support Approved**: Temporary limit increases
- **Algorithm**: `effectiveLimit = max(tierDefault, memberOverride)`

### Temporary Increases [#temporary-increases]
- **Duration**: Usually 30-90 days
- **Approval**: Requires support ticket
- **Use Cases**: Special events, bulk gifting campaigns
- **Monitoring**: Increased fraud monitoring during override period

## Use Cases [#use-cases]

### Pre-Transfer Validation [#pre-transfer-validation]
```typescript
const validateTransfer = async (amount: number) => {
  const response = await fetch('/api/members/me/transfers/limits');
  const limits = await response.json();
  
  const errors = [];
  
  if (amount < limits.minimumTransfer) {
    errors.push(`Minimum transfer is ${limits.minimumTransfer} points`);
  }
  
  if (amount > limits.perTransferMax) {
    errors.push(`Maximum per transfer is ${limits.perTransferMax} points`);
  }
  
  if (amount > limits.dailyRemaining) {
    errors.push(`Daily limit exceeded. ${limits.dailyRemaining} points remaining today`);
  }
  
  if (amount > limits.monthlyRemaining) {
    errors.push(`Monthly limit exceeded. ${limits.monthlyRemaining} points remaining this month`);
  }
  
  return {
    valid: errors.length === 0,
    errors,
    limits
  };
};
```

### Display Transfer Capacity [#display-transfer-capacity]
```typescript
const displayTransferLimits = async () => {
  const response = await fetch('/api/members/me/transfers/limits');
  const limits = await response.json();
  
  const maxTransferToday = Math.min(
    limits.perTransferMax,
    limits.dailyRemaining,
    limits.monthlyRemaining
  );
  
  return {
    maxTransferToday,
    dailyProgress: (limits.dailyUsed / limits.dailyLimit) * 100,
    monthlyProgress: (limits.monthlyUsed / limits.monthlyLimit) * 100,
    resetTimes: {
      daily: getNextMidnightUTC(),
      monthly: getFirstOfNextMonthUTC()
    }
  };
};
```

### Bulk Transfer Planning [#bulk-transfer-planning]
```typescript
const planBulkTransfers = async (recipients: number[], amount: number) => {
  const response = await fetch('/api/members/me/transfers/limits');
  const limits = await response.json();
  
  const totalAmount = recipients.length * amount;
  const maxTransfersToday = Math.floor(limits.dailyRemaining / amount);
  const maxTransfersThisMonth = Math.floor(limits.monthlyRemaining / amount);
  
  return {
    canTransferAll: totalAmount <= Math.min(limits.dailyRemaining, limits.monthlyRemaining),
    maxToday: Math.min(recipients.length, maxTransfersToday),
    maxThisMonth: Math.min(recipients.length, maxTransfersThisMonth),
    needsSpread: totalAmount > limits.dailyRemaining,
    daysRequired: Math.ceil(totalAmount / limits.dailyLimit)
  };
};
```

## Performance Notes [#performance-notes]

### Caching [#caching]
- **Server-side**: Limits cached for 5 minutes
- **Client-side**: Safe to cache for 1-2 minutes
- **Invalidation**: Updated after each transfer

### Real-time Updates [#real-time-updates]
- **Usage Tracking**: Updated immediately after transfers
- **Limit Changes**: Applied within 5 minutes
- **Overrides**: Applied immediately after approval

## Monitoring & Alerts [#monitoring--alerts]

### Near Limit Warnings [#near-limit-warnings]
```typescript
const checkLimitWarnings = (limits) => {
  const warnings = [];
  
  if (limits.dailyRemaining < limits.dailyLimit * 0.1) {
    warnings.push('Approaching daily transfer limit');
  }
  
  if (limits.monthlyRemaining < limits.monthlyLimit * 0.1) {
    warnings.push('Approaching monthly transfer limit');
  }
  
  return warnings;
};
```

### Usage Analytics [#usage-analytics]
- **Daily Pattern**: Track typical daily usage
- **Monthly Trends**: Monitor monthly transfer patterns
- **Limit Utilization**: Percentage of limits used
- **Optimization**: Suggest limit adjustments based on usage

## Related Endpoints [#related-endpoints]

- [Create Transfer](/api-reference/members/me/transfers/create-transfer) - Use limits for transfer validation
- [List Pending Transfers](/api-reference/members/me/transfers/list-pending) - View transfers that count toward limits
- [Get Wallet Balance](/api-reference/members/wallet/get-balance) - Check available points for transfer