> For the complete documentation index, see [llms.txt](https://docs.graphlit.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.graphlit.dev/api-guides/use-cases/feeds/feed-get-details.md).

# Get Feed Details

## User Intent

"I want to retrieve full configuration details for a specific feed"

## Operation

* **SDK Method**: `graphlit.getFeed()`
* **GraphQL**: `getFeed` query
* **Entity Type**: Feed
* **Common Use Cases**: View feed configuration, check OAuth tokens, inspect sync settings

## TypeScript (Canonical)

```typescript
import { Graphlit } from 'graphlit-client';
import { FeedServiceTypes, FeedTypes } from 'graphlit-client/dist/generated/graphql-types';

const graphlit = new Graphlit();

const feedId = 'feed-id-here';

// Get full feed details
const feed = await graphlit.getFeed(feedId);

console.log(`\nFeed: ${feed.feed.name}`);
console.log(`Type: ${feed.feed.type}`);
console.log(`State: ${feed.feed.state}`);
console.log(`Created: ${feed.feed.creationDate}`);

// Check type-specific configuration
switch (feed.feed.type) {
  case FeedTypes.Slack: {
    if (!feed.feed.slack) break;
    console.log(`\nSlack Configuration:`);
    console.log(`  Channel: ${feed.feed.slack.channel}`);
    console.log(`  Listing: ${feed.feed.slack.type}`);
    console.log(`  Read Limit: ${feed.feed.slack.readLimit}`);
    console.log(`  Include Attachments: ${feed.feed.slack.includeAttachments}`);
    break;
  }
  case FeedTypes.Web: {
    if (!feed.feed.web) break;
    console.log(`\nWeb Configuration:`);
    console.log(`  Start URI: ${feed.feed.web.uri}`);
    console.log(`  Read Limit: ${feed.feed.web.readLimit}`);
    console.log(`  Include Files: ${feed.feed.web.includeFiles}`);
    console.log(`  Allowed Domains: ${feed.feed.web.allowedDomains?.join(', ')}`);
    break;
  }
  case FeedTypes.Rss: {
    if (!feed.feed.rss) break;
    console.log(`\nRSS Configuration:`);
    console.log(`  URI: ${feed.feed.rss.uri}`);
    console.log(`  Read Limit: ${feed.feed.rss.readLimit}`);
    break;
  }
  case FeedTypes.MicrosoftTeams: {
    if (!feed.feed.microsoftTeams) break;
    console.log(`\nMicrosoft Teams Configuration:`);
    console.log(`  Team ID: ${feed.feed.microsoftTeams.teamId}`);
    console.log(`  Channel ID: ${feed.feed.microsoftTeams.channelId}`);
    console.log(`  Listing: ${feed.feed.microsoftTeams.type}`);
    console.log(`  Read Limit: ${feed.feed.microsoftTeams.readLimit}`);
    console.log(`  Include Attachments: ${feed.feed.microsoftTeams.includeAttachments}`);
    break;
  }
  case FeedTypes.Site: {
    if (!feed.feed.site) break;

    if (feed.feed.site.type === FeedServiceTypes.GoogleDrive) {
      console.log(`\nGoogle Drive Configuration:`);
      console.log(`  Folder ID: ${feed.feed.site.googleDrive?.folderId ?? 'Drive root'}`);
      console.log(`  Files: ${feed.feed.site.googleDrive?.files?.join(', ') ?? 'None'}`);
      console.log(`  Read Limit: ${feed.feed.site.readLimit}`);
    }
    break;
  }
  default: {
    console.log('\nNo specialized configuration for this feed type.');
  }
}
```

## Python

```python
from graphlit import Graphlit

graphlit = Graphlit()

feed_id = "feed-id-here"

feed = await graphlit.client.get_feed(id=feed_id)

print(f"Feed: {feed.feed.name}")
print(f"Type: {feed.feed.type}")
print(f"State: {feed.feed.state}")

if feed.feed.type == "SLACK" and feed.feed.slack:
    print(f"Channel: {feed.feed.slack.channel}")
    print(f"Listing: {feed.feed.slack.type}")
    print(f"ReadLimit: {feed.feed.slack.read_limit}")
    print(f"IncludeAttachments: {feed.feed.slack.include_attachments}")
```

## .NET

```csharp
using GraphlitClient;
using System.Net.Http;
using StrawberryShake;

using var httpClient = new HttpClient();
var graphlit = new Graphlit(httpClient);

var feedId = "feed-id-here";

var response = await graphlit.Client.GetFeed.ExecuteAsync(feedId);
response.EnsureNoErrors();

var feed = response.Data?.Feed;

Console.WriteLine($"Feed: {feed?.Name}");
Console.WriteLine($"Type: {feed?.Type}");
Console.WriteLine($"State: {feed?.State}");

if (feed?.Type == FeedTypes.Slack && feed.Slack != null)
{
    Console.WriteLine($"Channel: {feed.Slack.Channel}");
    Console.WriteLine($"Listing: {feed.Slack.Type}");
    Console.WriteLine($"ReadLimit: {feed.Slack.ReadLimit}");
    Console.WriteLine($"IncludeAttachments: {feed.Slack.IncludeAttachments}");
}
```

## Parameters

* **`id`** (string): Feed ID

## Response

```typescript
{
  feed: {
    id: string;
    name: string;
    type: FeedTypes;
    state: EntityState;
    creationDate: Date;
    slack?: SlackFeedProperties;
    google?: GoogleFeedProperties;
    rss?: RSSFeedProperties;
    web?: WebFeedProperties;
  }
}
```

## Developer Hints

### Inspect Configuration

```typescript
import { FeedServiceTypes, FeedTypes } from 'graphlit-client/dist/generated/graphql-types';

const feed = await graphlit.getFeed(feedId);

// Check what type of feed
switch (feed.feed.type) {
  case FeedTypes.Slack:
    console.log('Slack feed');
    console.log('Channel:', feed.feed.slack?.channel);
    break;
  case FeedTypes.Web:
    console.log('Web crawl feed');
    console.log('Starting URL:', feed.feed.web?.uri);
    break;
  case FeedTypes.Rss:
    console.log('RSS feed');
    console.log('Feed URL:', feed.feed.rss?.uri);
    break;
  case FeedTypes.Site:
    if (feed.feed.site?.type === FeedServiceTypes.GoogleDrive) {
      console.log('Google Drive feed');
      console.log('Folder ID:', feed.feed.site.googleDrive?.folderId);
      console.log('Files:', feed.feed.site.googleDrive?.files);
    }
    break;
}
```

### Check OAuth Token Status

```typescript
const feed = await graphlit.getFeed(feedId);

// OAuth tokens are not returned for security
// If feed is syncing, token is valid
// If feed has errors, token may be expired

if (feed.feed.state === EntityState.Enabled) {
  console.log(' Feed is active');
} else {
  console.log(' Feed is disabled');
}
```

## Variations

### 1. Basic Feed Retrieval

```typescript
const feed = await graphlit.getFeed(feedId);
console.log(feed.feed.name);
```

### 2. Check Configuration

```typescript
const feed = await graphlit.getFeed(feedId);

console.log('Configuration:');
console.log(`  Type: ${feed.feed.type}`);
console.log(`  State: ${feed.feed.state}`);
```

### 3. Verify Sync Settings

```typescript
const feed = await graphlit.getFeed(feedId);

if (feed.feed.web) {
  console.log('Web crawl settings:');
  console.log(`  Max pages: ${feed.feed.web.readLimit}`);
  console.log(`  Include files: ${feed.feed.web.includeFiles}`);
}
```

## Production Example

**Feed health check**:

```typescript
async function checkFeedHealth(feedId: string) {
  const feed = await graphlit.getFeed(feedId);
  
  console.log(`=== FEED HEALTH: ${feed.feed.name} ===`);
  console.log(`Type: ${feed.feed.type}`);
  console.log(`State: ${feed.feed.state}`);
  console.log(`Created: ${new Date(feed.feed.creationDate).toLocaleDateString()}`);
  
  // Check if syncing
  const isDone = await graphlit.isFeedDone(feedId);
  console.log(`Sync Status: ${isDone.isFeedDone.result ? 'Complete' : 'In Progress'}`);
  
  // Count synced content
  const contents = await graphlit.queryContents({
    feeds: [{ id: feedId }]
  });
  console.log(`Content Items: ${contents.contents.results.length}`);
  
  // Health indicator
  const isHealthy = 
    feed.feed.state === EntityState.Enabled && 
    contents.contents.results.length > 0;
  
  console.log(`Health: ${isHealthy ? ' Healthy' : ' Issues Detected'}`);
}

await checkFeedHealth(feedId);
```