Name: PDF to Text API: Extract Text from PDF Files (Upload/URL)
Brand: viv-data
SKU: api-viv-data-pdf-text
Availability: InStock
Author: API Market

gia ly bui

# PDF to Text Extractor — Upload or URL

## Overview
The PDF to Text Extractor API provides a robust solution for extracting textual content from PDF documents. Developers can either upload a PDF file directly or provide a URL to a PDF, and the API will return the clean text content along with the total page count. Built with a fast PyMuPDF backend, this API is designed for efficiency and accuracy in text extraction tasks.

## Features
*   **Flexible Input:** Submit PDF files by direct upload or by providing a public URL.
*   **High Accuracy:** Leverages the fast PyMuPDF backend for reliable text extraction.
*   **Comprehensive Output:** Returns the full extracted text, original filename, page count, and text length.
*   **Simple Integration:** Easy-to-use API endpoints designed for quick integration into any application.
*   **Scalable:** Suitable for various document processing volumes, from single files to large archives.

## Use Cases
The PDF to Text Extractor API is versatile and can be applied across numerous industries and applications:

*   **Document Management Systems:** Automate the indexing and search capabilities within document repositories by extracting text from contracts, reports, and manuals.
*   **Data Analysis & Research:** Facilitate the analysis of large volumes of research papers, legal documents, or financial reports by quickly converting them into searchable text data.
*   **Content Indexing for Search Engines:** Enable powerful full-text search functionalities for digital libraries, e-commerce product manuals, or academic databases by extracting content from PDF catalogs and articles.
*   **Compliance & Auditing:** Streamline the review of regulatory documents, audit trails, and policy manuals by extracting key information for automated compliance checks and record-keeping.
*   **Educational Platforms:** Convert lecture notes, textbooks, and study materials into accessible text formats for students, enhancing learning experiences and content adaptability.

## Pricing
This API offers flexible pricing tiers based on your usage:

*   **Free Tier:** 500 requests per month
*   **Pro Tier:** $19.99 for 5,000 requests per month

Please note that 1 API unit equals 1 PDF processed. Different pricing tiers are available based on usage volume to accommodate various needs.

## API Documentation

### Base URL
All API requests should be made to:
`https://prod.api.market/api/v1/viv-data/pdf-text`

### Authentication
Authentication is handled via API key. Include your API key in the `x-api-market-key` header for all requests:

```
x-api-market-key: YOUR_API_MARKET_KEY
```


### Endpoints

#### 1. Extract Text from Uploaded PDF
This endpoint allows you to upload a PDF file directly and extract its text content.

**`POST /api/v1/viv-data/pdf-text/extract`**

**Summary:** Upload a PDF file and extract its text content.

**Request Body:**
`multipart/form-data` with a single `file` field.

| Name | Type   | Description | Required |
| :--- | :----- | :---------- | :------- |
| `file` | `binary` | The PDF file to be processed. | Yes      |

**Response (200 OK):**
Returns a JSON object containing the extracted text and metadata.

```json
{
  "filename": "document.pdf",
  "pages": 12,
  "text": "Full extracted text content...",
  "text_length": 15234
}
```

**cURL Example:**
```bash
curl -X POST "https://prod.api.market/api/v1/viv-data/pdf-text/extract" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -F "file=@/path/to/your/document.pdf"
```

#### 2. Extract Text from PDF URL
This endpoint allows you to provide a URL to a PDF file for text extraction.

**`GET /api/v1/viv-data/pdf-text/extract-url`**

**Summary:** Provide a URL to a PDF file and extract its text content.

**Query Parameters:**

| Name | Type   | Description | Required |
| :--- | :----- | :---------- | :------- |
| `url` | `string` | The URL of the PDF file to be processed. | Yes      |

**Response (200 OK):**
Returns a JSON object containing the extracted text and metadata.

```json
{
  "filename": "document.pdf",
  "pages": 12,
  "text": "Full extracted text content...",
  "text_length": 15234
}
```

**cURL Example:**
```bash
curl -X GET "https://prod.api.market/api/v1/viv-data/pdf-text/extract-url?url=https://example.com/document.pdf" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## Status Codes
The API uses standard HTTP status codes to indicate the success or failure of a request.

*   **200 OK:** The request was successful, and the response body contains the requested data.
*   **201 Created:** (Not typically used by this API, as it performs extraction, not creation of new persistent resources).
*   **400 Bad Request:** The request was malformed or contained invalid input parameters. This could occur if the provided URL is invalid, or the uploaded file is not a valid PDF.
*   **401 Unauthorized:** The API key `x-api-market-key` is missing or invalid. Ensure your API key is correctly included in the request header.
*   **403 Forbidden:** Your API key is valid, but you do not have sufficient permissions to access the requested resource or perform the operation. This might indicate a problem with your subscription plan.
*   **404 Not Found:** The requested endpoint or resource was not found. Check the URL for typos.
*   **422 Unprocessable Entity:** The request was well-formed but could not be processed due to semantic errors, such as invalid data types for query parameters (e.g., `url` not being a string).
*   **429 Too Many Requests:** You have exceeded your API rate limits. Refer to the Rate Limits section for more information.
*   **500 Internal Server Error:** A server-side error occurred while processing your request. This is usually a temporary issue; if it persists, contact support.
*   **503 Service Unavailable:** The service is temporarily unable to handle your request, often due to maintenance or overload. Retry the request after a short delay.


## Implementation Guide
This section provides code examples for integrating with the PDF to Text Extractor API using various programming languages. Since this is a synchronous API, the final result is returned directly in the response.

### Example Code

#### JavaScript

```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/viv-data/pdf-text";

async function extractTextFromUrl(pdfUrl) {
  try {
    const response = await fetch(`${baseUrl}/extract-url?url=${encodeURIComponent(pdfUrl)}`, {
      method: "GET",
      headers: {
        "x-api-market-key": apiKey
      },
      // You might want to add a timeout here for longer-running requests
      // e.g., using AbortController, but not standard in fetch directly.
    });

    if (!response.ok) {
      const errorData = await response.json().catch(() => ({ message: response.statusText }));
      throw new Error(`API error: ${response.status} - ${JSON.stringify(errorData)}`);
    }

    const result = await response.json();
    return result;
  } catch (error) {
    console.error("Error extracting text from URL:", error);
    throw error;
  }
}

async function extractTextFromFile(file) {
  try {
    const formData = new FormData();
    formData.append("file", file); // 'file' should be a File or Blob object

    const response = await fetch(`${baseUrl}/extract`, {
      method: "POST",
      headers: {
        "x-api-market-key": apiKey
        // Content-Type is automatically set to multipart/form-data by fetch when using FormData
      },
      body: formData
    });

    if (!response.ok) {
      const errorData = await response.json().catch(() => ({ message: response.statusText }));
      throw new Error(`API error: ${response.status} - ${JSON.stringify(errorData)}`);
    }

    const result = await response.json();
    return result;
  } catch (error) {
    console.error("Error extracting text from file:", error);
    throw error;
  }
}

// Example usage:
// const pdfUrl = "https://www.africau.edu/images/default/sample.pdf";
// extractTextFromUrl(pdfUrl)
//   .then(data => console.log("Extracted text from URL:", data))
//   .catch(err => console.error(err));

// Example usage for file upload (e.g., from an input field):
// const fileInput = document.getElementById('pdfFileInput');
// fileInput.addEventListener('change', async (event) => {
//   const selectedFile = event.target.files[0];
//   if (selectedFile) {
//     extractTextFromFile(selectedFile)
//       .then(data => console.log("Extracted text from file:", data))
//       .catch(err => console.error(err));
//   }
// });
```

#### Python

```python
import requests
import os

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/viv-data/pdf-text"

def extract_text_from_url(pdf_url):
    headers = {
        "x-api-market-key": API_KEY
    }
    params = {
        "url": pdf_url
    }

    try:
        response = requests.get(
            f"{BASE_URL}/extract-url",
            headers=headers,
            params=params,
            timeout=120  # Set a timeout for the request (e.g., 120 seconds)
        )
        response.raise_for_status()  # Raise an exception for HTTP errors (4xx or 5xx)
        return response.json()
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err} - {response.text}")
        raise
    except requests.exceptions.ConnectionError as conn_err:
        print(f"Connection error occurred: {conn_err}")
        raise
    except requests.exceptions.Timeout as timeout_err:
        print(f"Request timed out: {timeout_err}")
        raise
    except requests.exceptions.RequestException as req_err:
        print(f"An unexpected error occurred: {req_err}")
        raise

def extract_text_from_file(file_path):
    headers = {
        "x-api-market-key": API_KEY
    }
    
    # Ensure the file exists
    if not os.path.exists(file_path):
        raise FileNotFoundError(f"File not found at: {file_path}")

    try:
        with open(file_path, "rb") as f:
            files = {'file': f}
            response = requests.post(
                f"{BASE_URL}/extract",
                headers=headers,
                files=files,
                timeout=120 # Set a timeout for the request
            )
        response.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
        return response.json()
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP error occurred: {http_err} - {response.text}")
        raise
    except requests.exceptions.ConnectionError as conn_err:
        print(f"Connection error occurred: {conn_err}")
        raise
    except requests.exceptions.Timeout as timeout_err:
        print(f"Request timed out: {timeout_err}")
        raise
    except requests.exceptions.RequestException as req_err:
        print(f"An unexpected error occurred: {req_err}")
        raise

# Example usage:
# pdf_url_example = "https://www.africau.edu/images/default/sample.pdf"
# try:
#     result_url = extract_text_from_url(pdf_url_example)
#     print("Extracted text from URL:", result_url)
# except Exception as e:
#     print(f"Failed to extract from URL: {e}")

# file_path_example = "/path/to/your/document.pdf"
# # Make sure 'document.pdf' exists at the specified path for this example to work
# try:
#     result_file = extract_text_from_file(file_path_example)
#     print("Extracted text from file:", result_file)
# except Exception as e:
#     print(f"Failed to extract from file: {e}")
```

#### cURL

##### Extract text from a PDF available at a URL

```bash
curl -X GET "https://prod.api.market/api/v1/viv-data/pdf-text/extract-url?url=https://example.com/document.pdf" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Example Response**

```json
{
  "filename": "document.pdf",
  "pages": 12,
  "text": "Full extracted text content...",
  "text_length": 15234
}
```

---

##### Extract text from an uploaded PDF file

> Replace `/path/to/your/document.pdf` with the actual path to your PDF file.

```bash
curl -X POST "https://prod.api.market/api/v1/viv-data/pdf-text/extract" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -F "file=@/path/to/your/document.pdf"
```

**Example Response**

```json
{
  "filename": "document.pdf",
  "pages": 12,
  "text": "Full extracted text content...",
  "text_length": 15234
}
```

### Performance Optimization
To maximize efficiency and minimize costs when using the PDF to Text Extractor API:

*   **Batch Processing (Client-Side):** If you have many PDFs, consider implementing client-side queuing and processing them sequentially or in small batches rather than sending all requests simultaneously to avoid hitting rate limits.
*   **Optimal File Size:** Be mindful of the PDF size. While there isn't a strict documented limit beyond "Render's request limits" (which implies typical web request body limits), larger files naturally take longer to process. Optimize PDFs where possible without sacrificing quality if only text is needed.
*   **Error Handling and Retries:** Implement robust error handling with exponential backoff for transient errors (`429`, `500`, `503`) to ensure your application gracefully handles temporary service interruptions without excessive retries.
*   **Client-Side Timeouts:** As a synchronous API, ensure your client-side code has appropriate timeouts configured (e.g., 60-120 seconds) for network requests to prevent indefinite waits for large or complex PDF extractions.

## FAQ

**Q: What is the maximum character limit for extracted text?**

A: The API returns a maximum of 50,000 characters per PDF. Text exceeding this limit will be truncated.

**Q: Can this API extract text from scanned PDFs?**

A: Scanned PDFs without an underlying OCR (Optical Character Recognition) layer may return empty text. The API primarily extracts text embedded within the PDF structure.

**Q: Are there limitations on PDF file size?**

A: Yes, PDF file size is limited by general API request limits. For very large PDFs, consider optimizing them or splitting them if possible before uploading.

**Q: How do I handle errors from the API?**

A: The API returns standard HTTP status codes and detailed JSON error messages. Refer to the Error Handling section for guidance on interpreting these responses and implementing retry strategies.

**Q: Is there a free tier available for testing?**

A: Yes, a free tier is available, offering 500 requests per month. This is perfect for initial development and testing.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.

Extract text from PDF documents quickly and accurately using the PDF to Text API. Supports file uploads or direct URL parsing with a fast PyMuPDF backend.