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

# Personalization

> Tailor DeFi experiences based on creditworthiness and financial profile

Personalizing product experiences is a way to tailor the user experience to the account owner's specific needs and preferences. By doing so, the product or service can be made more relevant and useful to the user. This can be achieved by using data and analytics to understand the account's asset level and creditworthiness, and then using that information to customize the user experience.

## Why Personalize?

<CardGroup cols={2}>
  <Card title="Relevance" icon="bullseye">
    Show users products and features that match their financial profile
  </Card>

  <Card title="Engagement" icon="hand-pointer">
    Increase interaction by surfacing the most appropriate options first
  </Card>

  <Card title="Conversion" icon="chart-line">
    Improve conversion rates by presenting suitable products to qualified users
  </Card>

  <Card title="User Experience" icon="face-smile">
    Reduce friction by hiding irrelevant or inaccessible options
  </Card>
</CardGroup>

***

## Aligning with Creditworthiness

One way to personalize product experiences is to align the user experience with a user's asset level and creditworthiness.

### High Creditworthiness Users

If a user has a high asset level and creditworthiness, they may be offered more complex and advanced financial products such as high risk/reward yield strategies:

* Leveraged yield farming
* Delta-neutral strategies
* Under-collateralized lending options
* Premium liquidity pools
* Advanced trading features

### Lower Creditworthiness Users

If a user has a lower asset level and creditworthiness, they may be offered lower risk financial products:

* Liquid staking derivatives
* Stable yield pools
* Over-collateralized lending
* Beginner-friendly interfaces
* Educational content and guides

***

## Implementation Example

```javascript theme={null}
async function getPersonalizedDashboard(address) {
  const response = await fetch(
    `https://api.credprotocol.com/api/v2/score/address/${address}?include_factors=true`,
    { headers: { 'Authorization': `Bearer ${API_KEY}` } }
  );

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

  // Determine user tier based on creditworthiness
  const userTier = getUserTier(score);

  // Get personalized product recommendations
  const recommendations = getRecommendations(userTier, factors);

  // Customize UI elements
  const dashboardConfig = {
    tier: userTier,
    featuredProducts: recommendations.featured,
    availableStrategies: recommendations.strategies,
    promotedFeatures: recommendations.features,
    riskLevel: recommendations.maxRisk,
    showAdvancedOptions: score >= 840,
    showLeveragedProducts: score >= 920,
  };

  return dashboardConfig;
}

function getUserTier(score) {
  if (score >= 920) return 'premium';
  if (score >= 840) return 'advanced';
  if (score >= 750) return 'standard';
  if (score >= 640) return 'basic';
  return 'starter';
}

function getRecommendations(tier, factors) {
  const recommendations = {
    premium: {
      featured: ['leveraged-farming', 'delta-neutral', 'undercollateralized-loans'],
      strategies: ['aggressive', 'balanced', 'conservative'],
      features: ['advanced-analytics', 'api-access', 'priority-support'],
      maxRisk: 'high',
    },
    advanced: {
      featured: ['yield-optimizer', 'lending-pools', 'staking'],
      strategies: ['balanced', 'conservative'],
      features: ['portfolio-tracking', 'alerts'],
      maxRisk: 'medium-high',
    },
    standard: {
      featured: ['staking', 'stable-pools', 'lending'],
      strategies: ['balanced', 'conservative'],
      features: ['basic-analytics'],
      maxRisk: 'medium',
    },
    basic: {
      featured: ['liquid-staking', 'stable-yields'],
      strategies: ['conservative'],
      features: ['tutorials', 'guides'],
      maxRisk: 'low',
    },
    starter: {
      featured: ['learn-and-earn', 'stable-savings'],
      strategies: ['conservative'],
      features: ['onboarding', 'education'],
      maxRisk: 'minimal',
    },
  };

  return recommendations[tier];
}
```

***

## Personalization Patterns

### Dynamic Feature Promotion

Promote capabilities that are popular with account owners with similar levels of creditworthiness:

```javascript theme={null}
async function getPopularFeatures(userScore) {
  // Define score bands
  const scoreBand = Math.floor(userScore / 100) * 100;

  // Features popular with users in similar score ranges
  const popularByBand = {
    900: ['leveraged-positions', 'cross-chain-strategies', 'governance'],
    800: ['yield-optimization', 'liquidity-provision', 'staking'],
    700: ['lending', 'borrowing', 'stable-yields'],
    600: ['savings', 'staking', 'swaps'],
    default: ['tutorials', 'stable-savings', 'small-swaps'],
  };

  return popularByBand[scoreBand] || popularByBand.default;
}
```

### Adaptive UI Components

Adjust the interface based on user profile:

```javascript theme={null}
function renderProductCard(product, userScore) {
  const isAccessible = userScore >= product.minScore;
  const isRecommended = userScore >= product.recommendedScore;

  return {
    ...product,
    // Visual treatment
    highlighted: isRecommended,
    dimmed: !isAccessible,

    // Call-to-action
    ctaText: isAccessible ? 'Get Started' : `Requires ${product.minScore}+ score`,
    ctaEnabled: isAccessible,

    // Additional context
    badge: isRecommended ? 'Recommended for you' : null,
    tooltip: !isAccessible
      ? `Improve your score to ${product.minScore} to unlock this product`
      : null,
  };
}
```

### Personalized Messaging

Tailor communication based on creditworthiness:

```javascript theme={null}
function getWelcomeMessage(range) {
  const messages = {
    excellent: {
      headline: 'Welcome back, valued member',
      subtitle: 'Explore our premium strategies designed for experienced DeFi users',
      cta: 'View Premium Options',
    },
    very_good: {
      headline: 'Great to see you',
      subtitle: 'Your strong credit profile unlocks advanced features',
      cta: 'Explore Advanced Features',
    },
    good: {
      headline: 'Welcome',
      subtitle: 'Discover yield opportunities matched to your profile',
      cta: 'Browse Opportunities',
    },
    fair: {
      headline: 'Welcome',
      subtitle: 'Start building your DeFi portfolio with these curated options',
      cta: 'Get Started',
    },
    low: {
      headline: 'Welcome to DeFi',
      subtitle: 'Begin your journey with beginner-friendly products',
      cta: 'Start Learning',
    },
  };

  return messages[range] || messages.low;
}
```

***

## Using Credit Reports for Deeper Personalization

For more granular personalization, use the full credit report:

```javascript theme={null}
async function getDetailedPersonalization(address) {
  const response = await fetch(
    `https://api.credprotocol.com/api/v2/report/address/${address}`,
    { headers: { 'Authorization': `Bearer ${API_KEY}` } }
  );

  const { report } = await response.json();
  const { summary } = report;

  return {
    // Asset-based personalization
    assetTier: getAssetTier(summary.total_asset_usd),

    // Activity-based personalization
    experienceLevel: getExperienceLevel(summary.count_transactions),

    // DeFi experience
    hasLendingHistory: summary.count_active_loans > 0 || summary.count_repayments > 0,
    hasNFTs: summary.count_nfts > 0,

    // Multi-chain activity
    isMultiChain: summary.count_chains_with_activity > 1,

    // Identity verification
    hasVerifiedIdentity: summary.count_identity_attestations > 0,
    attestations: summary.list_identity_attestations,
  };
}

function getAssetTier(totalAssetUsd) {
  if (totalAssetUsd >= 100000) return 'whale';
  if (totalAssetUsd >= 10000) return 'dolphin';
  if (totalAssetUsd >= 1000) return 'fish';
  return 'shrimp';
}

function getExperienceLevel(transactionCount) {
  if (transactionCount >= 1000) return 'veteran';
  if (transactionCount >= 100) return 'experienced';
  if (transactionCount >= 10) return 'intermediate';
  return 'beginner';
}
```

***

## Best Practices

<AccordionGroup>
  <Accordion title="Don't exclude, guide">
    Rather than hiding products entirely from lower-score users, show them what's available and what they need to do to qualify. This creates aspiration and engagement.
  </Accordion>

  <Accordion title="Explain personalization">
    Let users know their experience is personalized based on their on-chain activity. Transparency builds trust.
  </Accordion>

  <Accordion title="Allow exploration">
    Even if you recommend certain products, allow users to browse all options. Some users may have legitimate reasons to choose different products.
  </Accordion>

  <Accordion title="Update dynamically">
    Re-fetch credit data periodically to ensure personalization reflects the user's current status, not stale information.
  </Accordion>
</AccordionGroup>

***

## Benefits

| Benefit                | Description                                               |
| ---------------------- | --------------------------------------------------------- |
| Increased Engagement   | Users see relevant products, leading to more interaction  |
| Higher Conversion      | Presenting appropriate products improves conversion rates |
| Reduced Friction       | Users aren't overwhelmed with unsuitable options          |
| Better Risk Management | Users are guided toward products matching their profile   |
| Customer Satisfaction  | Tailored experiences feel more valuable to users          |

***

## Related

<CardGroup cols={2}>
  <Card title="Get Credit Report" icon="file-lines" href="/api-reference/report/get-report">
    API reference for detailed credit reports
  </Card>

  <Card title="Qualifying Access" icon="lock" href="/use-cases/qualifying-access">
    Gate access to products based on creditworthiness
  </Card>
</CardGroup>