Skip to main content
Capital-efficient lending uses credit scores and reports to lower collateral requirements for qualified borrowers—while still remaining over-collateralized. This approach unlocks significant value for borrowers and lenders alike, serving as a practical stepping stone toward full under-collateralized lending.

​
The Problem with Fixed Collateral Ratios

Most DeFi lending protocols use fixed collateral requirements regardless of borrower creditworthiness:
ProtocolTypical Collateral RatioBorrowing Power
Aave150-200%Borrow 50−66per50-66 per 100 deposited
Compound150-175%Borrow 57−66per57-66 per 100 deposited
MakerDAO150-170%Borrow 58−66per58-66 per 100 deposited
The issue: A first-time DeFi user with no history receives the same terms as a veteran with years of successful repayments. This one-size-fits-all approach:
  • Penalizes responsible borrowers
  • Limits capital efficiency for qualified users
  • Provides no incentive to build good credit behavior
  • Leaves value on the table for lenders

​
The Solution: Risk-Adjusted Collateral

By integrating credit scoring, protocols can offer tiered collateral requirements that reward creditworthy borrowers while maintaining protocol safety:

​
Capital-Efficient Tiers (Over-Collateralized)

TierMin ScoreCollateralvs Standard (150%)Identity Required
Excellent920+110%-40 pointsNo
Very Good840+120%-30 pointsNo
Good750+130%-20 pointsNo
Fair640+140%-10 pointsNo
BuildingBelow 640150%StandardNo
Even at reduced collateral ratios, loans remain over-collateralized (above 100%)—the protocol is always protected. The difference is that trusted borrowers aren’t unnecessarily penalized.
Ready for even better terms? Users with scores 750+ and verified identity may qualify for Under-Collateralized Lending with collateral below 100%.

​
Benefits

​
For Borrowers

Credit TierStandard TermsWith Credit ScoringImprovement
ExcellentBorrow 66per66 per 100Borrow 90per90 per 100+36% capital efficiency
Very GoodBorrow 66per66 per 100Borrow 80per80 per 100+21% capital efficiency
GoodBorrow 66per66 per 100Borrow 71per71 per 100+8% capital efficiency

​
For Lenders & Protocols

  • Increased utilization: Better terms attract more borrowing activity
  • Competitive advantage: Differentiate from protocols with fixed ratios
  • User retention: Borrowers stay where they’re rewarded for good behavior
  • Maintained safety: All loans remain over-collateralized

​
Implementation

​
Basic Collateral Adjustment

async function getCollateralRequirement(borrowerAddress, asset) {
  // Fetch credit score
  const response = await fetch(
    `https://api.credprotocol.com/api/v2/score/address/${borrowerAddress}`,
    { headers: { 'Authorization': `Bearer ${API_KEY}` } }
  );

  const { score, range } = await response.json();

  // Base collateral ratio for the asset (e.g., 150% for ETH)
  const baseRatio = getAssetBaseRatio(asset);

  // Credit-based discount
  const discount = getCollateralDiscount(score);

  // Calculate adjusted ratio (never below safety minimum)
  const adjustedRatio = Math.max(
    baseRatio - discount,
    getMinimumSafeRatio(asset)
  );

  return {
    baseRatio,
    adjustedRatio,
    discount,
    creditScore: score,
    creditRange: range,
  };
}

function getCollateralDiscount(score) {
  // Discount in percentage points based on credit score
  if (score >= 920) return 0.40;  // 40 percentage points off (150% → 110%)
  if (score >= 840) return 0.30;  // 30 points off (150% → 120%)
  if (score >= 750) return 0.20;  // 20 points off (150% → 130%)
  if (score >= 640) return 0.10;  // 10 points off (150% → 140%)
  return 0;                        // No discount
}

function getMinimumSafeRatio(asset) {
  // Minimum collateral ratio regardless of credit score
  // Based on asset volatility
  const minimums = {
    'ETH': 1.10,
    'WBTC': 1.10,
    'stablecoins': 1.05,
    'default': 1.15,
  };
  return minimums[asset] || minimums.default;
}

​
Enhanced Risk Assessment

For more sophisticated implementations, incorporate the full credit report: 
async function calculateRiskAdjustedTerms(borrowerAddress, loanRequest) {
  // Fetch comprehensive credit data
  const [scoreRes, reportRes] = await Promise.all([
    fetch(`https://api.credprotocol.com/api/v2/score/address/${borrowerAddress}?include_factors=true`, {
      headers: { 'Authorization': `Bearer ${API_KEY}` }
    }),
    fetch(`https://api.credprotocol.com/api/v2/report/address/${borrowerAddress}`, {
      headers: { 'Authorization': `Bearer ${API_KEY}` }
    })
  ]);

  const { score, factors } = await scoreRes.json();
  const { report } = await reportRes.json();

  // Start with base collateral ratio
  let collateralRatio = 1.50;

  // Apply credit score adjustment
  collateralRatio -= getCollateralDiscount(score);

  // Additional adjustments based on report data

  // Reward strong repayment history
  if (report.summary.count_repayments >= 10 && report.summary.count_liquidations === 0) {
    collateralRatio -= 0.05;
  }

  // Reward identity verification
  if (report.summary.count_identity_attestations >= 2) {
    collateralRatio -= 0.05;
  }

  // Penalize recent liquidations
  if (report.summary.count_liquidations > 0) {
    collateralRatio += 0.10;
  }

  // Adjust for loan size relative to net worth
  const loanToNetWorth = loanRequest.amount / report.summary.net_worth_usd;
  if (loanToNetWorth > 0.5) {
    collateralRatio += 0.10;  // Higher ratio for large loans relative to net worth
  }

  // Ensure minimum safety
  collateralRatio = Math.max(collateralRatio, 1.10);

  return {
    collateralRatio,
    requiredCollateral: loanRequest.amount * collateralRatio,
    maxBorrow: loanRequest.collateralValue / collateralRatio,
    creditScore: score,
    factors: {
      repaymentBonus: report.summary.count_repayments >= 10,
      identityBonus: report.summary.count_identity_attestations >= 2,
      liquidationPenalty: report.summary.count_liquidations > 0,
      largeLoanPenalty: loanToNetWorth > 0.5,
    },
  };
}

​
User Experience

​
Displaying Terms to Borrowers

function renderBorrowingTerms(terms, baseTerms) {
  const improvement = ((baseTerms.maxBorrow - terms.maxBorrow) / baseTerms.maxBorrow * -100).toFixed(0);

  return {
    headline: terms.collateralRatio < baseTerms.collateralRatio
      ? `Your credit score qualifies you for better terms!`
      : `Build your credit history to unlock better rates`,

    comparison: {
      standard: {
        label: 'Standard Terms',
        collateralRatio: `${(baseTerms.collateralRatio * 100).toFixed(0)}%`,
        maxBorrow: formatCurrency(baseTerms.maxBorrow),
      },
      yours: {
        label: 'Your Terms',
        collateralRatio: `${(terms.collateralRatio * 100).toFixed(0)}%`,
        maxBorrow: formatCurrency(terms.maxBorrow),
        highlight: terms.collateralRatio < baseTerms.collateralRatio,
      },
    },

    improvement: terms.collateralRatio < baseTerms.collateralRatio
      ? `+${Math.abs(improvement)}% more borrowing power`
      : null,

    factors: terms.factors,
  };
}

​
Incentivizing Credit Building

Show users how improving their score translates to better terms: 
function showImprovementPath(currentScore, currentRatio) {
  const tiers = [
    { minScore: 920, ratio: 1.10, label: 'Excellent' },
    { minScore: 840, ratio: 1.20, label: 'Very Good' },
    { minScore: 750, ratio: 1.30, label: 'Good' },
    { minScore: 640, ratio: 1.40, label: 'Fair' },
  ];

  const currentTier = tiers.find(t => currentScore >= t.minScore) || { label: 'Building' };
  const nextTier = tiers.find(t => t.minScore > currentScore);

  return {
    current: {
      tier: currentTier.label,
      ratio: currentRatio,
      score: currentScore,
    },
    next: nextTier ? {
      tier: nextTier.label,
      ratio: nextTier.ratio,
      scoreNeeded: nextTier.minScore,
      pointsAway: nextTier.minScore - currentScore,
      benefitDescription: `Unlock ${((currentRatio - nextTier.ratio) * 100).toFixed(0)}% lower collateral requirements`,
    } : null,
    tips: [
      'Make consistent loan repayments',
      'Maintain healthy collateral ratios',
      'Add identity attestations (ENS, Gitcoin Passport)',
      'Avoid liquidations',
    ],
  };
}

​
Safety Considerations

Capital-efficient lending must balance improved terms with protocol safety:
Never reduce collateral below asset-specific minimums. Even the most creditworthy borrowers should maintain at least 105-110% collateral to account for rapid price movements.
Apply different minimum ratios based on asset volatility. Stablecoins can have lower floors than volatile assets like ETH or WBTC.
Reduced collateral means less buffer before liquidation. Implement robust monitoring and alert systems.
Credit scores are cached for 5 minutes. For collateral calculations, this is usually sufficient, but consider the trade-off between freshness and API costs.
If the credit API is unavailable, fall back to standard collateral requirements rather than denying service.

​
Fallback Strategy

async function getCollateralRequirementWithFallback(borrowerAddress, asset) {
  try {
    const terms = await getCollateralRequirement(borrowerAddress, asset);
    return terms;
  } catch (error) {
    console.error('Credit score unavailable, using standard terms:', error);

    // Fall back to standard collateral requirements
    return {
      baseRatio: getAssetBaseRatio(asset),
      adjustedRatio: getAssetBaseRatio(asset),
      discount: 0,
      creditScore: null,
      creditRange: null,
      fallback: true,
    };
  }
}

​
The Path Forward

Capital-efficient lending is a stepping stone toward full under-collateralized lending:
1

Today: Fixed Over-Collateralization

150%+ collateral for everyone, regardless of creditworthiness
2

Next: Risk-Adjusted Over-Collateralization

110-150% collateral based on credit score—you are here
3

Future: Under-Collateralized Lending

50-100% collateral for highly qualified borrowers with verified identity
4

Vision: Reputation-Based Lending

Unsecured loans based on on-chain reputation and credit history
By implementing capital-efficient lending today, protocols can:
  • Build infrastructure for credit-based risk assessment
  • Establish user credit histories
  • Create incentives for good financial behavior
  • Prepare for the transition to under-collateralized products

Under-Collateralized Lending

The next step: lending with less than 100% collateral

Qualifying Access

Gate access to lending products by credit tier

Get Credit Score

API reference for fetching credit scores

Get Credit Report

Detailed borrower financial profiles