# Format Selection Guide
This guide helps you choose the right serialization format for your MARC data based on your use case.
## Quick Decision Tree
```
What's your primary goal?
│
├─ Exchange with other library systems?
│ └─ ISO 2709 (.mrc) - Universal compatibility
│
├─ Build a REST API?
│ └─ JSON or MARCJSON - Human-readable, widely supported
│
├─ Linked data / semantic web?
│ └─ BIBFRAME - RDF graph model for modern linked data
│
├─ Metadata crosswalks?
│ ├─ Simple metadata? → Dublin Core (15-element standard)
│ ├─ Detailed bibliographic? → MODS (bidirectional read/write)
│ └─ Import from MODS? → MODS read (crosswalk import)
│
├─ Spreadsheet export?
│ └─ CSV
│
└─ Long-term archival?
└─ ISO 2709 or JSON - Wide tool support
```
## Format Comparison
| **ISO 2709** | Fast | Compact | Universal | Library system interchange |
| **JSON** | Medium | Large | Universal | Web APIs, debugging |
| **MARCJSON** | Medium | Large | LOC Standard | Standards-compliant JSON |
| **XML** | Slow | Very Large | Universal | MARCXML systems |
| **CSV** | Fast | Medium | Universal | Spreadsheets, simple tools |
| **Dublin Core** | Fast | Medium | Universal | Simple metadata exchange |
| **MODS** | Medium | Large | Good | Detailed metadata crosswalks |
| **BIBFRAME** | Medium | Large | Growing | Linked data, RDF applications |
## Detailed Format Profiles
### ISO 2709 (MARC Binary)
**Use when:**
- Exchanging with traditional library systems (ILS, OCLC, etc.)
- Maximum compatibility is required
- Working with existing MARC workflows
**Avoid when:**
- Building modern web APIs
- Need for human-readable output
- Integrating with linked data systems
```python
# Reading
with open("records.mrc", "rb") as f:
for record in mrrc.MARCReader(f):
print(record.title)
# Writing
with open("output.mrc", "wb") as f:
with mrrc.MARCWriter(f) as writer:
writer.write(record)
```
### JSON / MARCJSON
**Use when:**
- Building web APIs that need human-readable responses
- Debugging or inspecting records
- JavaScript frontend integration
- MARCJSON when LOC standard compliance is required
**Avoid when:**
- Bandwidth is limited
- Processing millions of records
- Need binary efficiency
```python
# Single record
json_str = record.to_json()
marcjson_str = record.to_marcjson()
# Parse back
restored = mrrc.json_to_record(json_str)
```
### BIBFRAME
**Use when:**
- Building linked data applications
- Publishing bibliographic data as RDF
- Integrating with SPARQL endpoints or triple stores
- Following Library of Congress modernization initiatives
**Avoid when:**
- Simple record exchange between library systems
- Need for compact binary format
- Systems that only support traditional MARC
```python
from mrrc import marc_to_bibframe, BibframeConfig
config = BibframeConfig()
config.set_base_uri("http://library.example.org/")
graph = marc_to_bibframe(record, config)
# Serialize to Turtle, RDF/XML, JSON-LD, or N-Triples
turtle = graph.serialize("turtle")
```
See the [BIBFRAME Conversion Guide](bibframe-conversion.md) for details.
### CSV
**Use when:**
- Exporting to spreadsheets (Excel, Google Sheets)
- Simple data analysis tools
- Quick tabular view of MARC data
**Avoid when:**
- Need to preserve full MARC structure
- Round-trip conversion is required
```python
csv_str = mrrc.records_to_csv(records)
```
### Dublin Core
**Use when:**
- Simple metadata exchange across systems
- OAI-PMH harvesting
- Need 15-element standard metadata
```python
dc_xml = record.to_dublin_core()
```
### MODS
**Use when:**
- Detailed metadata crosswalks (bidirectional)
- Digital library applications
- Need richer metadata than Dublin Core
- Importing MODS records into MARC workflows
```python
# Convert to MODS XML
mods_xml = record.to_mods()
# Parse from MODS XML
record = mrrc.mods_to_record(mods_xml)
```
## Use Case Recommendations
### Library System Integration
**Recommended:** ISO 2709
Traditional library systems universally support ISO 2709. Use it for:
- OCLC WorldCat submissions
- ILS data migration
- Z39.50 compatible systems
### Web Application Backend
**Recommended:** JSON or MARCJSON
For APIs serving web or mobile clients:
- JSON for generic integration
- MARCJSON for LOC-compliant systems
### Linked Data / Semantic Web
**Recommended:** BIBFRAME
BIBFRAME enables integration with:
- SPARQL endpoints
- Triple stores
- Linked data ecosystems
- Library of Congress initiatives
### Metadata Crosswalks
**Recommended:** Dublin Core or MODS
- Dublin Core for simple, widely-supported metadata
- MODS for detailed bibliographic description
### Spreadsheet Export
**Recommended:** CSV
CSV works with Excel, Google Sheets, and simple data tools.
### Archival / Preservation
**Recommended:** ISO 2709 or JSON
- ISO 2709 for maximum future compatibility with library systems
- JSON for wide tool support and human readability
## Next Steps
- [BIBFRAME Conversion Guide](bibframe-conversion.md) - BIBFRAME conversion details
- [Format Conversion Tutorial](../tutorials/python/format-conversion.md) - Python format conversion examples
- [Working with Large Files](working-with-large-files.md) - Large file handling