# Get Position Bins

View all bins where a position has active liquidity. This method shows the liquidity distribution across different price levels within a specific position.

### Prerequisites

Before fetching position bins:

* Have a valid position ID
* Have the associated LBPair object
* Understand bin IDs and price relationships
* Position must belong to the specified pair

### Basic Usage

```typescript
// Get pair and position
const pair = await sdk.Pair.getPair(pairAddress);
const positionId = "0x123...abc";

// Fetch bins with liquidity
const bins = await sdk.Position.getPositionBins(pair, positionId);

console.log(`Position has liquidity in ${bins.length} bins`);

// Display bin details
bins.forEach(bin => {
  console.log(`Bin ${bin.id}: ${bin.liquidity.toString()} liquidity`);
});
```

### Method Signature

```typescript
async getPositionBins(
  pair: LBPair, 
  positionId: string
): Promise<BinData[]>
```

#### Parameters

* `pair`: The LBPair object where position exists
* `positionId`: The position NFT address

#### Returns

Array of `BinData` objects sorted by bin ID:

```typescript
interface BinData {
  id: number;           // Bin ID
  liquidity: bigint;    // LP token amount in this bin
}
```

### Understanding Bin Data

#### Liquidity Values

```typescript
const bins = await sdk.Position.getPositionBins(pair, positionId);

// Analyze liquidity distribution
const totalLiquidity = bins.reduce((sum, bin) => sum + bin.liquidity, 0n);
const averageLiquidity = totalLiquidity / BigInt(bins.length);

console.log("Position statistics:", {
  totalBins: bins.length,
  totalLiquidity: totalLiquidity.toString(),
  averageLiquidity: averageLiquidity.toString()
});
```

#### Price Range Coverage

```typescript
const bins = await sdk.Position.getPositionBins(pair, positionId);
const binStep = Number(pair.binStep);

if (bins.length > 0) {
  const minBinId = bins[0].id;
  const maxBinId = bins[bins.length - 1].id;
  
  const minPrice = getPriceFromBinId(minBinId, binStep);
  const maxPrice = getPriceFromBinId(maxBinId, binStep);
  
  console.log("Position price range:", {
    minPrice: minPrice.toFixed(4),
    maxPrice: maxPrice.toFixed(4),
    binsCount: bins.length,
    activebin: pair.parameters.active_id
  });
}
```

### Get Position Token Amounts

For detailed token amounts per bin:

```typescript
// Get bins with token amounts
const binsWithAmounts = await sdk.Position.getPositionBinsAmount(pair, positionId);

binsWithAmounts.forEach(bin => {
  console.log(`Bin ${bin.id}:`, {
    liquidity: bin.liquidity.toString(),
    amountX: bin.amountX.toString(),
    amountY: bin.amountY.toString()
  });
});

// Calculate total position value
const totals = binsWithAmounts.reduce((acc, bin) => ({
  x: acc.x + bin.amountX,
  y: acc.y + bin.amountY
}), { x: 0n, y: 0n });

console.log("Total position value:", totals);
```

### Analyze Position Shape

```typescript
const bins = await sdk.Position.getPositionBins(pair, positionId);
const activeId = pair.parameters.active_id;

// Categorize bins relative to current price
const analysis = {
  belowActive: bins.filter(b => b.id < activeId),
  atActive: bins.filter(b => b.id === activeId),
  aboveActive: bins.filter(b => b.id > activeId)
};

console.log("Position shape:", {
  binsBelow: analysis.belowActive.length,
  binsAtActive: analysis.atActive.length,
  binsAbove: analysis.aboveActive.length,
  isInRange: analysis.atActive.length > 0
});
```

### Liquidity Concentration

```typescript
const bins = await sdk.Position.getPositionBins(pair, positionId);

// Find bins with most liquidity
const sortedBins = [...bins].sort((a, b) => 
  Number(b.liquidity - a.liquidity)
);

const top5Bins = sortedBins.slice(0, 5);
const top5Liquidity = top5Bins.reduce((sum, b) => sum + b.liquidity, 0n);
const totalLiquidity = bins.reduce((sum, b) => sum + b.liquidity, 0n);

console.log("Concentration:", {
  top5Percentage: (Number(top5Liquidity) / Number(totalLiquidity) * 100).toFixed(2),
  mostConcentratedBin: top5Bins[0]?.id
});
```

### Common Patterns

#### Check if Position is Active

```typescript
const bins = await sdk.Position.getPositionBins(pair, positionId);
const activeId = pair.parameters.active_id;

const isActive = bins.some(bin => bin.id === activeId);
console.log("Position contains active bin:", isActive);
```

#### Visualize Distribution

```typescript
const bins = await sdk.Position.getPositionBins(pair, positionId);

// Create simple ASCII visualization
bins.forEach(bin => {
  const barLength = Number(bin.liquidity * 100n / maxLiquidity);
  const bar = "█".repeat(Math.min(barLength, 50));
  console.log(`Bin ${bin.id}: ${bar}`);
});
```

### Error Handling

```typescript
try {
  const bins = await sdk.Position.getPositionBins(pair, wrongPositionId);
} catch (error) {
  if (error.message.includes("not match with pair")) {
    console.error("Position doesn't belong to this pair");
  }
}
```

### Related Topics

* [Get Single Position](/integration/dlmm/typescript-sdk/position-management/get-single-position.md) - Fetch position metadata
* [Remove from Specific Bins](/integration/dlmm/typescript-sdk/remove-liquidity/remove-from-specific-bins.md) - Remove selected bins
* [Position Value](/integration/dlmm/typescript-sdk/fees-and-analytics/position-value.md) - Calculate bin values


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.ferra.ag/integration/dlmm/typescript-sdk/position-management/get-position-bins.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.