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

# Group Metadata

> Fetch and understand group metadata including participants, description, settings, and more

## Overview

Group metadata contains comprehensive information about a WhatsApp group, including its participants, settings, description, and various configuration options.

## Fetching Group Metadata

Use the `groupMetadata` method to retrieve complete information about a group.

### Function Signature

```typescript theme={null}
groupMetadata(jid: string): Promise<GroupMetadata>
```

**Parameters:**

* `jid` - The group JID (e.g., `'123456789@g.us'`)

**Returns:** A `GroupMetadata` object containing all group information

### Basic Example

```typescript theme={null}
const metadata = await sock.groupMetadata(jid)
console.log(metadata.id + ', title: ' + metadata.subject + ', description: ' + metadata.desc)
```

### Complete Usage

```typescript theme={null}
const getGroupInfo = async (groupJid: string) => {
  try {
    const metadata = await sock.groupMetadata(groupJid)

    console.log('Group Information:')
    console.log('ID:', metadata.id)
    console.log('Name:', metadata.subject)
    console.log('Description:', metadata.desc)
    console.log('Owner:', metadata.owner)
    console.log('Participants:', metadata.participants.length)
    console.log('Created:', new Date(metadata.creation! * 1000))

    return metadata
  } catch (error) {
    console.error('Failed to fetch group metadata:', error)
    throw error
  }
}
```

## GroupMetadata Interface

The complete structure of group metadata:

```typescript theme={null}
interface GroupMetadata {
  // Basic Information
  id: string                          // Group JID
  subject: string                     // Group name/title
  notify?: string                     // Notification name
  size?: number                       // Number of participants
  creation?: number                   // Creation timestamp (Unix)

  // Owner Information
  owner: string | undefined           // Creator JID
  ownerPn?: string                    // Creator phone number
  owner_country_code?: string         // Creator country code

  // Subject (Name) Metadata
  subjectOwner?: string               // Who last changed the name
  subjectOwnerPn?: string             // Subject owner phone number
  subjectTime?: number                // When name was last changed

  // Description Metadata
  desc?: string                       // Group description text
  descId?: string                     // Description ID
  descOwner?: string                  // Who set the description
  descOwnerPn?: string                // Description owner phone number
  descTime?: number                   // When description was set

  // Settings
  addressingMode?: WAMessageAddressingMode  // 'lid' or 'pn' messaging mode
  restrict?: boolean                  // Locked settings (admin only)
  announce?: boolean                  // Announcement mode (admin only messages)
  memberAddMode?: boolean             // Members can add participants
  joinApprovalMode?: boolean          // Approval required to join
  ephemeralDuration?: number          // Disappearing messages duration

  // Community
  linkedParent?: string               // Parent community JID
  isCommunity?: boolean               // Is this a community
  isCommunityAnnounce?: boolean       // Is community announcement group

  // Participants
  participants: GroupParticipant[]    // Array of group members

  // Additional
  inviteCode?: string                 // Current invite code
  author?: string                     // Person who added you/changed setting
  authorPn?: string                   // Author phone number
}
```

## GroupParticipant Interface

Each participant in the group has the following structure:

```typescript theme={null}
interface GroupParticipant {
  id: string                              // Participant JID
  phoneNumber?: string                    // Phone number (for LID users)
  lid?: string                            // LID identifier
  admin: 'admin' | 'superadmin' | null   // Admin status
}
```

## Working with Participants

### List All Participants

```typescript theme={null}
const listParticipants = async (groupJid: string) => {
  const metadata = await sock.groupMetadata(groupJid)

  console.log(`Group has ${metadata.participants.length} participants:\n`)

  metadata.participants.forEach(participant => {
    const role = participant.admin || 'member'
    console.log(`${participant.id} - ${role}`)
  })
}
```

### Get Admins Only

```typescript theme={null}
const getGroupAdmins = async (groupJid: string) => {
  const metadata = await sock.groupMetadata(groupJid)

  const admins = metadata.participants.filter(p => p.admin)

  console.log('Admins:')
  admins.forEach(admin => {
    console.log(`${admin.id} - ${admin.admin}`)
  })

  return admins
}
```

### Check if User is Admin

```typescript theme={null}
const isUserAdmin = async (groupJid: string, userJid: string) => {
  const metadata = await sock.groupMetadata(groupJid)

  const participant = metadata.participants.find(p => p.id === userJid)

  return participant?.admin !== null && participant?.admin !== undefined
}

// Usage
const isAdmin = await isUserAdmin(groupJid, '1234@s.whatsapp.net')
console.log('Is admin:', isAdmin)
```

### Check if User is Super Admin (Creator)

```typescript theme={null}
const isSuperAdmin = async (groupJid: string, userJid: string) => {
  const metadata = await sock.groupMetadata(groupJid)

  const participant = metadata.participants.find(p => p.id === userJid)

  return participant?.admin === 'superadmin'
}
```

## Checking Group Settings

### Display All Settings

```typescript theme={null}
const displayGroupSettings = async (groupJid: string) => {
  const metadata = await sock.groupMetadata(groupJid)

  console.log('Group Settings:')
  console.log('Announcement Mode:', metadata.announce ? 'ON' : 'OFF')
  console.log('Locked Settings:', metadata.restrict ? 'ON' : 'OFF')
  console.log('Member Can Add:', metadata.memberAddMode ? 'YES' : 'NO')
  console.log('Join Approval:', metadata.joinApprovalMode ? 'ON' : 'OFF')

  if (metadata.ephemeralDuration) {
    const days = metadata.ephemeralDuration / 86400
    console.log(`Ephemeral Messages: ${days} day(s)`)
  } else {
    console.log('Ephemeral Messages: OFF')
  }
}
```

### Check Specific Setting

```typescript theme={null}
const isAnnouncementGroup = async (groupJid: string) => {
  const metadata = await sock.groupMetadata(groupJid)
  return metadata.announce === true
}

const hasEphemeralEnabled = async (groupJid: string) => {
  const metadata = await sock.groupMetadata(groupJid)
  return metadata.ephemeralDuration !== undefined && metadata.ephemeralDuration > 0
}
```

## Fetching All Participating Groups

Get metadata for all groups you're a member of.

### Function Signature

```typescript theme={null}
groupFetchAllParticipating(): Promise<{ [jid: string]: GroupMetadata }>
```

### Fetch All Groups

```typescript theme={null}
const response = await sock.groupFetchAllParticipating()
console.log(response)
```

### Complete Example

```typescript theme={null}
const getAllGroups = async () => {
  const groups = await sock.groupFetchAllParticipating()

  const groupList = Object.values(groups)

  console.log(`You are in ${groupList.length} groups:\n`)

  groupList.forEach(group => {
    console.log(`${group.subject} (${group.id})`)
    console.log(`  Participants: ${group.participants.length}`)
    console.log(`  Created: ${new Date(group.creation! * 1000).toLocaleDateString()}`)
    console.log('')
  })

  return groups
}
```

### Filter Groups by Criteria

```typescript theme={null}
const findGroupsByName = async (searchTerm: string) => {
  const groups = await sock.groupFetchAllParticipating()

  const matchingGroups = Object.values(groups).filter(group =>
    group.subject.toLowerCase().includes(searchTerm.toLowerCase())
  )

  return matchingGroups
}

const getGroupsWhereAdmin = async () => {
  const groups = await sock.groupFetchAllParticipating()
  const myJid = sock.user?.id

  const adminGroups = Object.values(groups).filter(group => {
    const me = group.participants.find(p => p.id === myJid)
    return me?.admin !== null && me?.admin !== undefined
  })

  return adminGroups
}
```

## Description Metadata

Working with group descriptions:

```typescript theme={null}
const getDescriptionInfo = async (groupJid: string) => {
  const metadata = await sock.groupMetadata(groupJid)

  if (!metadata.desc) {
    console.log('No description set')
    return null
  }

  console.log('Description:', metadata.desc)
  console.log('Set by:', metadata.descOwner)
  
  if (metadata.descTime) {
    const date = new Date(metadata.descTime * 1000)
    console.log('Set on:', date.toLocaleString())
  }

  return {
    text: metadata.desc,
    owner: metadata.descOwner,
    time: metadata.descTime,
    id: metadata.descId
  }
}
```

## Community Groups

Check if a group is part of a community:

```typescript theme={null}
const getCommunityInfo = async (groupJid: string) => {
  const metadata = await sock.groupMetadata(groupJid)

  if (metadata.isCommunity) {
    console.log('This is a community')
  } else if (metadata.linkedParent) {
    console.log('This group is part of community:', metadata.linkedParent)
  } else {
    console.log('This is a standalone group')
  }

  if (metadata.isCommunityAnnounce) {
    console.log('This is a community announcement group')
  }

  return {
    isCommunity: metadata.isCommunity,
    linkedParent: metadata.linkedParent,
    isCommunityAnnounce: metadata.isCommunityAnnounce
  }
}
```

## Complete Analysis Function

Comprehensive group analysis:

<Steps>
  <Step title="Fetch and analyze">
    ```typescript theme={null}
    const analyzeGroup = async (groupJid: string) => {
      const metadata = await sock.groupMetadata(groupJid)

      // Basic Info
      console.log('=== GROUP ANALYSIS ===')
      console.log('Name:', metadata.subject)
      console.log('ID:', metadata.id)
      console.log('Created:', new Date(metadata.creation! * 1000).toLocaleString())
      console.log('Owner:', metadata.owner)

      // Participants Analysis
      console.log('\n=== PARTICIPANTS ===')
      const admins = metadata.participants.filter(p => p.admin === 'admin')
      const superAdmins = metadata.participants.filter(p => p.admin === 'superadmin')
      const members = metadata.participants.filter(p => !p.admin)

      console.log(`Total: ${metadata.participants.length}`)
      console.log(`Super Admins: ${superAdmins.length}`)
      console.log(`Admins: ${admins.length}`)
      console.log(`Members: ${members.length}`)

      // Settings
      console.log('\n=== SETTINGS ===')
      console.log('Announcement Mode:', metadata.announce ? 'ON' : 'OFF')
      console.log('Locked:', metadata.restrict ? 'YES' : 'NO')
      console.log('Members Can Add:', metadata.memberAddMode ? 'YES' : 'NO')
      console.log('Join Approval:', metadata.joinApprovalMode ? 'REQUIRED' : 'NOT REQUIRED')

      if (metadata.ephemeralDuration) {
        console.log('Ephemeral:', `${metadata.ephemeralDuration / 86400} days`)
      }

      // Description
      if (metadata.desc) {
        console.log('\n=== DESCRIPTION ===')
        console.log(metadata.desc)
      }

      return metadata
    }
    ```
  </Step>

  <Step title="Export data">
    ```typescript theme={null}
    const exportGroupData = async (groupJid: string) => {
      const metadata = await sock.groupMetadata(groupJid)

      const exportData = {
        basic: {
          id: metadata.id,
          name: metadata.subject,
          description: metadata.desc,
          created: new Date(metadata.creation! * 1000).toISOString(),
          owner: metadata.owner
        },
        settings: {
          announcementMode: metadata.announce,
          locked: metadata.restrict,
          memberCanAdd: metadata.memberAddMode,
          joinApproval: metadata.joinApprovalMode,
          ephemeralDuration: metadata.ephemeralDuration
        },
        participants: metadata.participants.map(p => ({
          jid: p.id,
          role: p.admin || 'member'
        })),
        community: {
          isCommunity: metadata.isCommunity,
          linkedParent: metadata.linkedParent,
          isCommunityAnnounce: metadata.isCommunityAnnounce
        }
      }

      return exportData
    }
    ```
  </Step>
</Steps>

## Best Practices

<Info>
  **Caching**: Group metadata doesn't change frequently. Consider caching it to reduce API calls.
</Info>

<Note>
  **Events**: The library emits `'groups.update'` events when metadata changes. Listen to these events to keep your cache updated.
</Note>

<Warning>
  **Privacy**: Be careful when storing or displaying participant information. Respect user privacy.
</Warning>

### Efficient Metadata Usage

```typescript theme={null}
// Cache metadata to avoid repeated fetches
const metadataCache = new Map<string, { data: GroupMetadata, timestamp: number }>()
const CACHE_TTL = 5 * 60 * 1000 // 5 minutes

const getCachedMetadata = async (groupJid: string) => {
  const cached = metadataCache.get(groupJid)
  const now = Date.now()

  if (cached && (now - cached.timestamp) < CACHE_TTL) {
    return cached.data
  }

  const metadata = await sock.groupMetadata(groupJid)
  metadataCache.set(groupJid, { data: metadata, timestamp: now })

  return metadata
}

// Listen for updates to invalidate cache
sock.ev.on('groups.update', (updates) => {
  updates.forEach(update => {
    metadataCache.delete(update.id)
  })
})
```

## Related Methods

* [Group Settings](/groups/group-settings) - Modify group configuration
* [Managing Participants](/groups/managing-participants) - Update participant roles
* [Invite Codes](/groups/invite-codes) - Get group invite information