0
# Confluence API
1

2
Comprehensive Confluence REST API client providing full access to Confluence content management, collaboration features, and administration. Supports both Confluence Cloud and Server/Data Center platforms with 130+ public methods covering pages, spaces, attachments, users, and system management.
3

4
## Initialization
5

6
```python { .api }
7
class Confluence(AtlassianRestAPI):
8
    def __init__(self, url: str, username: str = None, password: str = None,
9
                 token: str = None, cloud: bool = None, api_version: str = "latest",
10
                 **kwargs):
11
        """
12
        Initialize Confluence client.
13
        
14
        Parameters:
15
        - url (str): Base URL of Confluence instance
16
        - username (str, optional): Username for authentication
17
        - password (str, optional): Password or API token
18
        - token (str, optional): Bearer token for authentication
19
        - cloud (bool, optional): True for Cloud, False for Server/DC
20
        - api_version (str): API version, defaults to "latest"
21
        """
22
```
23

24
## Capabilities
25

26
### Page Management
27

28
Core functionality for creating, reading, updating, and managing Confluence pages with comprehensive content handling.
29

30
```python { .api }
31
def get_page_by_title(self, space: str, title: str, start: int = 0,
32
                      limit: int = 1, expand: Optional[str] = None,
33
                      type: str = "page") -> T_resp_json:
34
    """
35
    Get page by space key and title.
36
    
37
    Parameters:
38
    - space: Space key
39
    - title: Page title
40
    - start: Starting index for pagination
41
    - limit: Maximum results to return
42
    - expand: Additional data to expand (body.storage, version, etc.)
43
    - type: Content type ("page", "blogpost")
44
    
45
    Returns:
46
    dict: Page information with content and metadata
47
    """
48

49
def get_page_by_id(self, page_id: str, expand: Optional[str] = None,
50
                   status: Optional[str] = None, 
51
                   version: Optional[int] = None) -> T_resp_json:
52
    """
53
    Get page by ID.
54
    
55
    Parameters:
56
    - page_id: Page ID
57
    - expand: Additional data to expand
58
    - status: Page status filter
59
    - version: Specific version number
60
    
61
    Returns:
62
    dict: Page data with requested expansions
63
    """
64

65
def create_page(self, space: str, title: str, body: str,
66
                parent_id: Optional[str] = None, type: str = "page",
67
                representation: str = "storage", editor: Optional[str] = None,
68
                full_width: bool = False, status: str = "current") -> T_resp_json:
69
    """
70
    Create new page.
71
    
72
    Parameters:
73
    - space: Space key where page will be created
74
    - title: Page title
75
    - body: Page content in specified representation format
76
    - parent_id: Parent page ID for hierarchy
77
    - type: Content type ("page", "blogpost")
78
    - representation: Content format ("storage", "wiki", "view")
79
    - editor: Editor type ("v1", "v2", "fabric")
80
    - full_width: Use full page width
81
    - status: Page status ("current", "draft")
82
    
83
    Returns:
84
    dict: Created page data with ID and URL
85
    """
86

87
def update_page(self, page_id: str, title: str, body: Optional[str] = None,
88
                parent_id: Optional[str] = None, type: str = "page",
89
                representation: str = "storage", minor_edit: bool = False,
90
                version_comment: Optional[str] = None, 
91
                always_update: bool = False, full_width: bool = False) -> T_resp_json:
92
    """
93
    Update existing page.
94
    
95
    Parameters:
96
    - page_id: Page ID to update
97
    - title: New page title
98
    - body: New page content (optional if only updating title)
99
    - parent_id: New parent page ID
100
    - type: Content type
101
    - representation: Content format
102
    - minor_edit: Mark as minor edit
103
    - version_comment: Version comment for history
104
    - always_update: Update even if no changes detected
105
    - full_width: Use full page width
106
    
107
    Returns:
108
    dict: Updated page data
109
    """
110

111
def update_or_create(self, parent_id: str, title: str, body: str,
112
                     representation: str = "storage", minor_edit: bool = False,
113
                     version_comment: Optional[str] = None,
114
                     editor: Optional[str] = None, 
115
                     full_width: bool = False) -> T_resp_json:
116
    """
117
    Update page if exists, create if not.
118
    
119
    Parameters:
120
    - parent_id: Parent page ID
121
    - title: Page title
122
    - body: Page content
123
    - representation: Content format
124
    - minor_edit: Mark as minor edit if updating
125
    - version_comment: Version comment
126
    - editor: Editor type
127
    - full_width: Use full page width
128
    
129
    Returns:
130
    dict: Page data (created or updated)
131
    """
132

133
def page_exists(self, space: str, title: str, type: Optional[str] = None) -> bool:
134
    """
135
    Check if page exists.
136
    
137
    Parameters:
138
    - space: Space key
139
    - title: Page title
140
    - type: Content type filter
141
    
142
    Returns:
143
    bool: True if page exists
144
    """
145

146
def remove_page(self, page_id: str, status: Optional[str] = None,
147
                recursive: bool = False) -> bool:
148
    """
149
    Remove page.
150
    
151
    Parameters:
152
    - page_id: Page ID to remove
153
    - status: Target status ("trashed" or permanent deletion)
154
    - recursive: Remove child pages as well
155
    
156
    Returns:
157
    bool: True if removal successful
158
    """
159
```
160

161
### Page Hierarchy and Navigation
162

163
```python { .api }
164
def get_child_pages(self, page_id: str) -> List[dict]:
165
    """
166
    Get child pages.
167
    
168
    Parameters:
169
    - page_id: Parent page ID
170
    
171
    Returns:
172
    List[dict]: Child page list
173
    """
174

175
def get_page_ancestors(self, page_id: str) -> List[dict]:
176
    """
177
    Get page ancestors.
178
    
179
    Parameters:
180
    - page_id: Page ID
181
    
182
    Returns:
183
    List[dict]: Ancestor pages from root to parent
184
    """
185

186
def get_parent_content_id(self, page_id: str) -> Optional[str]:
187
    """
188
    Get parent page ID.
189
    
190
    Parameters:
191
    - page_id: Child page ID
192
    
193
    Returns:
194
    str: Parent page ID or None if no parent
195
    """
196

197
def get_subtree_of_content_ids(self, page_id: str) -> List[str]:
198
    """
199
    Get complete subtree of page IDs.
200
    
201
    Parameters:
202
    - page_id: Root page ID
203
    
204
    Returns:
205
    List[str]: All descendant page IDs
206
    """
207
```
208

209
### Content Operations
210

211
```python { .api }
212
def get_all_pages_from_space(self, space: str, start: int = 0, limit: int = 50,
213
                             status: Optional[str] = None, 
214
                             expand: Optional[str] = None,
215
                             content_type: str = "page") -> T_resp_json:
216
    """
217
    Get all pages from space.
218
    
219
    Parameters:
220
    - space: Space key
221
    - start: Starting index for pagination
222
    - limit: Maximum results per page
223
    - status: Status filter ("current", "draft", "trashed")
224
    - expand: Additional data to expand
225
    - content_type: Content type filter
226
    
227
    Returns:
228
    dict: Pages data with pagination info
229
    """
230

231
def get_all_pages_by_label(self, label: str, start: int = 0, limit: int = 50,
232
                           expand: Optional[str] = None) -> T_resp_json:
233
    """
234
    Get pages by label.
235
    
236
    Parameters:
237
    - label: Label to search for
238
    - start: Starting index
239
    - limit: Maximum results
240
    - expand: Additional data to expand
241
    
242
    Returns:
243
    dict: Labeled pages with pagination
244
    """
245

246
def append_page(self, page_id: str, title: str, append_body: str,
247
                parent_id: Optional[str] = None, type: str = "page",
248
                representation: str = "storage", 
249
                minor_edit: bool = False) -> T_resp_json:
250
    """
251
    Append content to page.
252
    
253
    Parameters:
254
    - page_id: Page ID to append to
255
    - title: Page title (required for API)
256
    - append_body: Content to append
257
    - parent_id: Parent page ID
258
    - type: Content type
259
    - representation: Content format
260
    - minor_edit: Mark as minor edit
261
    
262
    Returns:
263
    dict: Updated page data
264
    """
265

266
def is_page_content_is_already_updated(self, page_id: str, body: str,
267
                                       title: Optional[str] = None) -> bool:
268
    """
269
    Check if page content differs from provided content.
270
    
271
    Parameters:
272
    - page_id: Page ID to check
273
    - body: Content to compare against
274
    - title: Title to compare (optional)
275
    
276
    Returns:
277
    bool: True if content is already the same
278
    """
279
```
280

281
### Space Management
282

283
```python { .api }
284
def get_all_spaces(self, start: int = 0, limit: int = 50,
285
                   expand: Optional[str] = None, space_type: Optional[str] = None,
286
                   space_status: Optional[str] = None) -> T_resp_json:
287
    """
288
    Get all spaces.
289
    
290
    Parameters:
291
    - start: Starting index for pagination
292
    - limit: Maximum results per page
293
    - expand: Additional data to expand
294
    - space_type: Space type filter ("global", "personal")
295
    - space_status: Status filter ("current", "archived")
296
    
297
    Returns:
298
    dict: Spaces list with pagination
299
    """
300

301
def get_space(self, space_key: str, 
302
              expand: str = "description.plain,homepage",
303
              params: Optional[dict] = None) -> T_resp_json:
304
    """
305
    Get space details.
306
    
307
    Parameters:
308
    - space_key: Space key
309
    - expand: Additional data to expand
310
    - params: Additional query parameters
311
    
312
    Returns:
313
    dict: Space information with metadata
314
    """
315

316
def create_space(self, space_key: str, space_name: str) -> T_resp_json:
317
    """
318
    Create new space.
319
    
320
    Parameters:
321
    - space_key: Unique space key
322
    - space_name: Space display name
323
    
324
    Returns:
325
    dict: Created space data
326
    """
327

328
def delete_space(self, space_key: str) -> bool:
329
    """
330
    Delete space.
331
    
332
    Parameters:
333
    - space_key: Space key to delete
334
    
335
    Returns:
336
    bool: True if deletion successful
337
    """
338

339
def get_home_page_of_space(self, space_key: str) -> T_resp_json:
340
    """
341
    Get space homepage.
342
    
343
    Parameters:
344
    - space_key: Space key
345
    
346
    Returns:
347
    dict: Homepage data
348
    """
349
```
350

351
### Attachment Management
352

353
```python { .api }
354
def attach_file(self, filename: str, name: Optional[str] = None,
355
                content_type: Optional[str] = None, page_id: Optional[str] = None,
356
                title: Optional[str] = None, space: Optional[str] = None,
357
                comment: Optional[str] = None) -> T_resp_json:
358
    """
359
    Attach file to page.
360
    
361
    Parameters:
362
    - filename: Path to file to attach
363
    - name: Attachment name (defaults to filename)
364
    - content_type: MIME type
365
    - page_id: Target page ID
366
    - title: Target page title (used with space if no page_id)
367
    - space: Target space key (used with title if no page_id)
368
    - comment: Attachment comment
369
    
370
    Returns:
371
    dict: Attachment metadata
372
    """
373

374
def attach_content(self, content: bytes, name: str,
375
                   content_type: str = "application/binary",
376
                   page_id: Optional[str] = None, title: Optional[str] = None,
377
                   space: Optional[str] = None, 
378
                   comment: Optional[str] = None) -> T_resp_json:
379
    """
380
    Attach content from memory to page.
381
    
382
    Parameters:
383
    - content: Binary content to attach
384
    - name: Attachment name
385
    - content_type: MIME type
386
    - page_id: Target page ID
387
    - title: Target page title
388
    - space: Target space key
389
    - comment: Attachment comment
390
    
391
    Returns:
392
    dict: Attachment metadata
393
    """
394

395
def get_attachments_from_content(self, page_id: str, start: int = 0,
396
                                 limit: int = 50, expand: Optional[str] = None,
397
                                 filename: Optional[str] = None,
398
                                 media_type: Optional[str] = None) -> T_resp_json:
399
    """
400
    Get page attachments.
401
    
402
    Parameters:
403
    - page_id: Page ID
404
    - start: Starting index
405
    - limit: Maximum results
406
    - expand: Additional data to expand
407
    - filename: Filter by filename
408
    - media_type: Filter by media type
409
    
410
    Returns:
411
    dict: Attachments list with metadata
412
    """
413

414
def download_attachments_from_page(self, page_id: str, path: Optional[str] = None,
415
                                   start: int = 0, limit: int = 50,
416
                                   filename: Optional[str] = None,
417
                                   to_memory: bool = False) -> Union[None, List[bytes]]:
418
    """
419
    Download attachments from page.
420
    
421
    Parameters:
422
    - page_id: Page ID
423
    - path: Download directory path
424
    - start: Starting index
425
    - limit: Maximum attachments to download
426
    - filename: Specific filename to download
427
    - to_memory: Return content in memory instead of saving files
428
    
429
    Returns:
430
    None or List[bytes]: Downloaded content if to_memory=True
431
    """
432

433
def delete_attachment(self, page_id: str, filename: str,
434
                      version: Optional[int] = None) -> bool:
435
    """
436
    Delete attachment.
437
    
438
    Parameters:
439
    - page_id: Page ID
440
    - filename: Attachment filename
441
    - version: Specific version to delete
442
    
443
    Returns:
444
    bool: True if deletion successful
445
    """
446
```
447

448
### Comments and Collaboration
449

450
```python { .api }
451
def add_comment(self, page_id: str, text: str) -> T_resp_json:
452
    """
453
    Add comment to page.
454
    
455
    Parameters:
456
    - page_id: Page ID
457
    - text: Comment text (supports wiki markup)
458
    
459
    Returns:
460
    dict: Created comment data
461
    """
462

463
def get_page_comments(self, content_id: str, expand: Optional[str] = None,
464
                      parent_version: Optional[int] = None, start: int = 0,
465
                      limit: int = 25, location: Optional[str] = None,
466
                      depth: Optional[str] = None) -> T_resp_json:
467
    """
468
    Get page comments.
469
    
470
    Parameters:
471
    - content_id: Page ID
472
    - expand: Additional data to expand
473
    - parent_version: Parent version filter
474
    - start: Starting index
475
    - limit: Maximum results
476
    - location: Comment location filter
477
    - depth: Comment depth ("root", "all")
478
    
479
    Returns:
480
    dict: Comments data with threading
481
    """
482

483
def share_with_others(self, page_id: str, group: str, message: str) -> bool:
484
    """
485
    Share page with group and send notification.
486
    
487
    Parameters:
488
    - page_id: Page ID to share
489
    - group: Group name to notify
490
    - message: Notification message
491
    
492
    Returns:
493
    bool: True if sharing successful
494
    """
495
```
496

497
### Labels and Properties
498

499
```python { .api }
500
def get_page_labels(self, page_id: str, prefix: Optional[str] = None,
501
                    start: Optional[int] = None, 
502
                    limit: Optional[int] = None) -> T_resp_json:
503
    """
504
    Get page labels.
505
    
506
    Parameters:
507
    - page_id: Page ID
508
    - prefix: Label prefix filter
509
    - start: Starting index
510
    - limit: Maximum results
511
    
512
    Returns:
513
    dict: Labels data
514
    """
515

516
def set_page_label(self, page_id: str, label: str) -> T_resp_json:
517
    """
518
    Add label to page.
519
    
520
    Parameters:
521
    - page_id: Page ID
522
    - label: Label to add
523
    
524
    Returns:
525
    dict: Label operation result
526
    """
527

528
def remove_page_label(self, page_id: str, label: str) -> T_resp_json:
529
    """
530
    Remove label from page.
531
    
532
    Parameters:
533
    - page_id: Page ID
534
    - label: Label to remove
535
    
536
    Returns:
537
    dict: Label operation result
538
    """
539

540
def get_page_properties(self, page_id: str) -> T_resp_json:
541
    """
542
    Get all page properties.
543
    
544
    Parameters:
545
    - page_id: Page ID
546
    
547
    Returns:
548
    dict: Page properties
549
    """
550

551
def set_page_property(self, page_id: str, data: dict) -> T_resp_json:
552
    """
553
    Set page property.
554
    
555
    Parameters:
556
    - page_id: Page ID
557
    - data: Property data with key and value
558
    
559
    Returns:
560
    dict: Property operation result
561
    """
562

563
def get_page_property(self, page_id: str, page_property_key: str) -> T_resp_json:
564
    """
565
    Get specific page property.
566
    
567
    Parameters:
568
    - page_id: Page ID
569
    - page_property_key: Property key
570
    
571
    Returns:
572
    dict: Property value
573
    """
574
```
575

576
### Search and Query
577

578
```python { .api }
579
def cql(self, cql: str, start: int = 0, limit: Optional[int] = None,
580
        expand: Optional[str] = None, 
581
        include_archived_spaces: Optional[bool] = None,
582
        excerpt: Optional[str] = None) -> T_resp_json:
583
    """
584
    Confluence Query Language search.
585
    
586
    Parameters:
587
    - cql: CQL query string
588
    - start: Starting index for pagination
589
    - limit: Maximum results to return
590
    - expand: Additional data to expand
591
    - include_archived_spaces: Include archived spaces in results
592
    - excerpt: Excerpt strategy ("highlight", "indexed", "none")
593
    
594
    Returns:
595
    dict: Search results with content matches
596
    """
597
```
598

599
### User and Group Management
600

601
```python { .api }
602
def get_user_details_by_username(self, username: str, 
603
                                 expand: Optional[str] = None) -> T_resp_json:
604
    """
605
    Get user details by username.
606
    
607
    Parameters:
608
    - username: Username to lookup
609
    - expand: Additional data to expand
610
    
611
    Returns:
612
    dict: User information
613
    """
614

615
def get_user_details_by_accountid(self, accountid: str,
616
                                  expand: Optional[str] = None) -> T_resp_json:
617
    """
618
    Get user details by account ID (Cloud).
619
    
620
    Parameters:
621
    - accountid: Account ID to lookup
622
    - expand: Additional data to expand
623
    
624
    Returns:
625
    dict: User information
626
    """
627

628
def get_all_groups(self, start: int = 0, limit: int = 1000) -> T_resp_json:
629
    """
630
    Get all groups.
631
    
632
    Parameters:
633
    - start: Starting index
634
    - limit: Maximum results
635
    
636
    Returns:
637
    dict: Groups list
638
    """
639

640
def create_group(self, name: str) -> T_resp_json:
641
    """
642
    Create group.
643
    
644
    Parameters:
645
    - name: Group name
646
    
647
    Returns:
648
    dict: Created group data
649
    """
650

651
def get_group_members(self, group_name: str = "confluence-users",
652
                      start: int = 0, limit: int = 1000,
653
                      expand: Optional[str] = None) -> T_resp_json:
654
    """
655
    Get group members.
656
    
657
    Parameters:
658
    - group_name: Group name
659
    - start: Starting index
660
    - limit: Maximum results
661
    - expand: Additional data to expand
662
    
663
    Returns:
664
    dict: Group members list
665
    """
666

667
def add_user_to_group(self, username: str, group_name: str) -> T_resp_json:
668
    """
669
    Add user to group.
670
    
671
    Parameters:
672
    - username: Username to add
673
    - group_name: Target group name
674
    
675
    Returns:
676
    dict: Operation result
677
    """
678
```
679

680
### Templates
681

682
```python { .api }
683
def create_or_update_template(self, name: str, body: str,
684
                              template_type: str = "page",
685
                              template_id: Optional[str] = None,
686
                              description: Optional[str] = None,
687
                              labels: Optional[List[str]] = None,
688
                              space: Optional[str] = None) -> T_resp_json:
689
    """
690
    Create or update content template.
691
    
692
    Parameters:
693
    - name: Template name
694
    - body: Template body content
695
    - template_type: Template type ("page", "blogpost")
696
    - template_id: Template ID for updates
697
    - description: Template description
698
    - labels: Template labels
699
    - space: Space key for space templates
700
    
701
    Returns:
702
    dict: Template data
703
    """
704

705
def get_content_templates(self, space: Optional[str] = None, start: int = 0,
706
                          limit: Optional[int] = None,
707
                          expand: Optional[str] = None) -> T_resp_json:
708
    """
709
    Get content templates.
710
    
711
    Parameters:
712
    - space: Space key filter
713
    - start: Starting index
714
    - limit: Maximum results
715
    - expand: Additional data to expand
716
    
717
    Returns:
718
    dict: Templates list
719
    """
720

721
def remove_template(self, template_id: str) -> bool:
722
    """
723
    Delete template.
724
    
725
    Parameters:
726
    - template_id: Template ID to delete
727
    
728
    Returns:
729
    bool: True if deletion successful
730
    """
731
```
732

733
### Export and Content Conversion
734

735
```python { .api }
736
def get_page_as_pdf(self, page_id: str) -> bytes:
737
    """
738
    Export page as PDF.
739
    
740
    Parameters:
741
    - page_id: Page ID to export
742
    
743
    Returns:
744
    bytes: PDF content
745
    """
746

747
def get_page_as_word(self, page_id: str) -> bytes:
748
    """
749
    Export page as Word document.
750
    
751
    Parameters:
752
    - page_id: Page ID to export
753
    
754
    Returns:
755
    bytes: Word document content
756
    """
757

758
def convert_wiki_to_storage(self, wiki: str) -> T_resp_json:
759
    """
760
    Convert wiki markup to storage format.
761
    
762
    Parameters:
763
    - wiki: Wiki markup content
764
    
765
    Returns:
766
    dict: Storage format content
767
    """
768

769
def convert_storage_to_view(self, storage: str) -> T_resp_json:
770
    """
771
    Convert storage format to view format.
772
    
773
    Parameters:
774
    - storage: Storage format content
775
    
776
    Returns:
777
    dict: View format content
778
    """
779
```
780

781
### History and Versioning
782

783
```python { .api }
784
def history(self, page_id: str) -> T_resp_json:
785
    """
786
    Get page history.
787
    
788
    Parameters:
789
    - page_id: Page ID
790
    
791
    Returns:
792
    dict: Version history with authors and timestamps
793
    """
794

795
def get_content_history_by_version_number(self, content_id: str,
796
                                          version_number: int) -> T_resp_json:
797
    """
798
    Get specific version of content.
799
    
800
    Parameters:
801
    - content_id: Content ID
802
    - version_number: Version number
803
    
804
    Returns:
805
    dict: Historical version data
806
    """
807

808
def remove_content_history(self, page_id: str, version_number: int) -> bool:
809
    """
810
    Remove specific version from history.
811
    
812
    Parameters:
813
    - page_id: Page ID
814
    - version_number: Version to remove
815
    
816
    Returns:
817
    bool: True if removal successful
818
    """
819
```
820

821
## Usage Examples
822

823
### Basic Page Operations
824

825
```python
826
from atlassian import Confluence
827

828
confluence = Confluence(
829
    url="https://your-domain.atlassian.net",
830
    username="email@example.com",
831
    password="api-token"
832
)
833

834
# Create page
835
page_body = """
836
<p>This is a new page with <strong>formatted content</strong>.</p>
837
<ac:structured-macro ac:name="info">
838
  <ac:parameter ac:name="title">Note</ac:parameter>
839
  <ac:rich-text-body>
840
    <p>This is an info macro.</p>
841
  </ac:rich-text-body>
842
</ac:structured-macro>
843
"""
844

845
new_page = confluence.create_page(
846
    space="DOCS",
847
    title="My New Page",
848
    body=page_body,
849
    parent_id="123456"
850
)
851

852
# Get page
853
page = confluence.get_page_by_title(
854
    "DOCS", 
855
    "My New Page", 
856
    expand="body.storage,version,ancestors"
857
)
858

859
# Update page
860
confluence.update_page(
861
    page_id=page["id"],
862
    title="Updated Page Title",
863
    body="<p>Updated content</p>"
864
)
865
```
866

867
### Content Management
868

869
```python
870
# Get all pages from space
871
pages = confluence.get_all_pages_from_space(
872
    "DOCS",
873
    expand="body.storage,version",
874
    limit=100
875
)
876

877
# Search with CQL
878
search_results = confluence.cql(
879
    'space = "DOCS" AND title ~ "API" AND type = "page"',
880
    expand="body.view"
881
)
882

883
# Work with labels
884
confluence.set_page_label(page_id, "api-docs")
885
confluence.set_page_label(page_id, "reference")
886
labels = confluence.get_page_labels(page_id)
887
```
888

889
### Attachments and Media
890

891
```python
892
# Attach file
893
attachment = confluence.attach_file(
894
    filename="/path/to/document.pdf",
895
    page_id=page_id,
896
    comment="Updated API documentation"
897
)
898

899
# Get attachments
900
attachments = confluence.get_attachments_from_content(page_id)
901

902
# Download attachments
903
confluence.download_attachments_from_page(
904
    page_id,
905
    path="/download/directory"
906
)
907
```
908

909
### Space and User Management
910

911
```python
912
# Create space
913
space = confluence.create_space(
914
    space_key="NEWDOCS",
915
    space_name="New Documentation Space"
916
)
917

918
# Get space info
919
space_info = confluence.get_space(
920
    "DOCS",
921
    expand="description.plain,homepage,permissions"
922
)
923

924
# User operations
925
user = confluence.get_user_details_by_username("john.doe")
926
groups = confluence.get_all_groups()
927
members = confluence.get_group_members("confluence-administrators")
928
```
929

930
### Advanced Operations
931

932
```python
933
# Content conversion
934
wiki_content = "h1. My Heading\n\nThis is *bold* text."
935
storage_content = confluence.convert_wiki_to_storage(wiki_content)
936

937
# Templates
938
template = confluence.create_or_update_template(
939
    name="Meeting Notes Template",
940
    body="<h1>Meeting Notes</h1><p>Date: </p><p>Attendees: </p>",
941
    description="Standard template for meeting notes"
942
)
943

944
# Export operations
945
pdf_content = confluence.get_page_as_pdf(page_id)
946
with open("page.pdf", "wb") as f:
947
    f.write(pdf_content)
948

949
# Page hierarchy
950
children = confluence.get_child_pages(parent_page_id)
951
ancestors = confluence.get_page_ancestors(page_id)
952
```
953

954
## Error Handling
955

956
```python
957
from atlassian.errors import ApiNotFoundError, ApiPermissionError
958

959
try:
960
    page = confluence.get_page_by_title("INVALID", "Nonexistent Page")
961
except ApiNotFoundError:
962
    print("Page not found")
963
except ApiPermissionError:
964
    print("Permission denied")
965
```
966

967
## Types
968

969
```python { .api }
970
from atlassian.typehints import T_id, T_resp_json
971
from typing import List, Dict, Optional, Union
972

973
# Common parameter types
974
SpaceKey = str
975
PageTitle = str
976
ContentId = str
977
ContentRepresentation = str  # "storage", "wiki", "view"
978
ContentStatus = str  # "current", "draft", "trashed"
979
CQLQuery = str
980
```