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

# Transcript to Document Example

> Complete example of converting call transcripts into structured documents

## Overview

This example demonstrates how to:

* Process a call transcript
* Extract key information
* Generate structured documents
* Apply custom templates
* Handle multiple speakers

## Basic Example

### Input Transcript

```json theme={null}
{
  "call_id": "call_123",
  "participants": [
    {"id": "user_1", "name": "John (Sales)"},
    {"id": "user_2", "name": "Sarah (Customer)"}
  ],
  "transcript": [
    {
      "speaker": "user_1",
      "timestamp": "00:00:05",
      "text": "Hi Sarah, thanks for joining today. We'll discuss the new features you requested."
    },
    {
      "speaker": "user_2",
      "timestamp": "00:00:12",
      "text": "Yes, specifically I'm interested in the API integration capabilities."
    }
  ]
}
```

### Generate Summary Document

```bash theme={null}
curl -X POST https://api.buildbetter.app/v1/documents \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "meeting_summary",
    "source": {
      "call_id": "call_123"
    },
    "options": {
      "format": "markdown",
      "template": "customer_meeting",
      "include_action_items": true
    }
  }'
```

### Output Document

```markdown theme={null}
# Customer Meeting Summary
Date: January 15, 2024
Duration: 45 minutes
Participants: John (Sales), Sarah (Customer)

## Key Points
- Discussed new feature requests
- Focus on API integration capabilities
- Customer interested in Salesforce connection

## Action Items
1. [ ] Send API documentation to Sarah
2. [ ] Schedule technical review for integration
3. [ ] Provide pricing for API access tier

## Next Steps
- Follow-up meeting scheduled for next week
- Technical team to review requirements
```

## Advanced Processing

<AccordionGroup>
  <Accordion title="Custom Templates">
    ```yaml theme={null}
    template_config:
      name: "customer_meeting"
      sections:
        - title: "Key Points"
          extraction:
            method: "topic_clustering"
            min_points: 3
        
        - title: "Action Items"
          extraction:
            method: "task_detection"
            assignee_required: true
        
        - title: "Next Steps"
          extraction:
            method: "future_planning"
            timeframe: "next_2_weeks"
    ```
  </Accordion>

  <Accordion title="Signal Detection">
    ```yaml theme={null}
    signal_rules:
      feature_request:
        patterns:
          - "need capability for"
          - "would like to have"
          - "missing feature"
        
      customer_pain:
        patterns:
          - "struggling with"
          - "difficult to"
          - "pain point"
    ```
  </Accordion>
</AccordionGroup>

## Processing Options

### Content Selection

```yaml theme={null}
processing_options:
  content_filters:
    include:
      - key_points
      - action_items
      - decisions
      - follow_ups
    
    exclude:
      - small_talk
      - technical_issues
      - interruptions
```

### Format Options

```yaml theme={null}
format_settings:
  markdown:
    headers:
      style: "atx"  # Use # headers
      max_level: 3
    
    lists:
      style: "hyphen"
      indent: 2
    
    emphasis:
      bold: "**"
      italic: "_"
```

<Note>
  Customize processing options to match your document requirements and organizational standards.
</Note>

## Real-World Example

### Sales Call to PRD

<Steps>
  <Step title="Record Sales Call" stepNumber={1}>
    Ask the BuildBetter recorder to join the meeting. This operation requires a user access token.

    ```bash theme={null}
    curl -X POST https://api.buildbetter.app/v3/rest/recordings/meeting-joins \
      -H "Authorization: Bearer USER_ACCESS_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{
        "type": "meetingUrl",
        "joinUrl": "https://zoom.us/j/123456789"
      }'
    ```

    Store the public `recordingId` from the `201 Created` response.
  </Step>

  <Step title="Fetch the Transcript" stepNumber={2}>
    Recording and transcription continue asynchronously. When the transcript is ready, fetch sentence-level utterances by public recording UUID.

    ```bash theme={null}
    curl "https://api.buildbetter.app/v3/rest/recordings/{recordingId}/transcript?type=utterance" \
      -H "X-BuildBetter-Api-Key: ORGANIZATION_API_KEY"
    ```
  </Step>

  <Step title="Generate PRD" stepNumber={3}>
    In BuildBetter, create a document using the completed recording as source material, choose your PRD template, and refine the generated draft.
  </Step>
</Steps>

### Example PRD Output

```markdown theme={null}
# Product Requirements: Enterprise API Integration

## Overview
Based on customer discussion on January 15, 2024

## Market Context
Enterprise customer seeking API integration capabilities for:
- Salesforce data synchronization
- Custom webhook support
- Batch processing capabilities

## User Stories
As an enterprise customer, I want to:
1. Sync customer data with Salesforce
2. Process data in batches of 1000+ records
3. Receive webhook notifications for updates

## Technical Requirements
- REST API endpoints for CRUD operations
- OAuth 2.0 authentication
- Rate limiting: 10,000 requests/hour
- 99.9% uptime SLA

## Implementation Timeline
- Phase 1: Basic API endpoints (Q1 2024)
- Phase 2: Batch processing (Q2 2024)
- Phase 3: Webhook system (Q3 2024)
```

## Best Practices

### Transcript Quality

* Ensure clear audio quality
* Use speaker identification
* Mark important segments
* Note key decisions

### Document Generation

* Choose appropriate templates
* Set clear extraction rules
* Review and refine output
* Maintain consistency

<Warning>
  Always review automatically generated documents before sharing with stakeholders.
</Warning>

## Template Customization

### Custom Fields

```yaml theme={null}
template_fields:
  customer_context:
    type: "text"
    source: "participant_info"
    required: true
  
  business_value:
    type: "list"
    source: "signal_analysis"
    min_items: 2
  
  technical_scope:
    type: "structured"
    format: "requirements"
    required: true
```

### Document Structure

```yaml theme={null}
document_structure:
  sections:
    - title: "Executive Summary"
      content: ["context", "objectives"]
      max_length: 500
    
    - title: "Detailed Requirements"
      content: ["user_stories", "technical_specs"]
      format: "nested_list"
    
    - title: "Next Steps"
      content: ["action_items", "timeline"]
      required: true
```

<Tip>
  Create templates that match your organization's documentation standards and workflows.
</Tip>

## Integration Example

### Jira Integration

```javascript theme={null}
// After document generation, create Jira tickets
const response = await buildbetter.documents.create({
  type: 'technical_specs',
  source: { call_id: 'call_123' },
  integrations: {
    jira: {
      project_key: 'PROD',
      issue_type: 'Story',
      auto_create: true
    }
  }
});
```

<Info>
  BuildBetter can automatically create tickets and tasks in connected systems based on generated documents.
</Info>