Webz.io News Search API makes it easy to find relevant news across millions of articles using natural-language queries. Describe what you're looking for in plain language, and the API returns the articles and content that best match your search. Refine results by source, country, language, publication date, sentiment, and category to focus on exactly the news you need. Built for AI applications, media intelligence, financial analysis, risk monitoring, and research, the API delivers structured news data that can be integrated directly into your product or workflow.

# Overview
Webz.io News Search API lets developers search global news coverage using a natural-language query instead of rigid keyword syntax. Given a plain-language description of a topic, the API returns the matching articles, the most relevant text chunks from each article, and structured metadata, making it suitable for AI applications, media intelligence, financial analysis, risk monitoring, and research workflows.

# Authentication
Requests are authenticated with a Bearer token, sent in the `Authorization` header:

```
Authorization: Bearer YOUR_API_KEY
```

News Search uses the same Webz API token and `api_news` permission as the Webz.io News API.

# Base URL
```
http://api.webz.io/api/news/context
```

# Endpoints

## Search news
`POST /api/news/context`

Searches global news using a natural-language query and returns matching articles, relevant excerpts, and metadata. By default, results are ranked by best match and capped at 10 items; the API also supports semantic matching, so results don't need to contain the exact query terms.

**Required parameter**
| Parameter | Type | Description |
|---|---|---|
| `query` | string | Free-text description of the topic to search for |

**Optional filters**
| Parameter | Type | Description |
|---|---|---|
| `language` | array of strings | Restrict results to one or more languages (e.g. `["english"]`) |
| `country` | array of strings | Restrict results to source country codes (e.g. `["US", "GB"]`) |
| `category` | array of strings | Restrict results to one or more of 17 fixed categories (e.g. `["business"]`) — includes Arts/Culture/Entertainment, Crime/Law/Justice, Disaster and Accident, Economy/Business/Finance, Education, Environment, Health, Human Interest, Labor, Lifestyle and Leisure, Politics, Religion and Belief, Science and Technology, Social Issue, Sport, War/Conflict/Unrest, and Weather |
| `sentiment` | array of strings | Restrict results by tone: `positive`, `negative`, or `neutral` |
| `published_from` | string (`YYYY-MM-DD`) | Only return articles published on or after this date |
| `domain` | array of strings | Restrict results to specific source domains (e.g. `["cnn.com", "yahoo.com"]`) |

If no language is specified and the query has more than two words, the API attempts to auto-detect the query language; an explicit `language` filter always takes priority.

**Example request**
```bash
curl -s -X POST "http://api.webz.io/api/news/context" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "query": "renewable energy investments in Germany",
    "language": ["english"],
    "category": ["environment"]
  }'
```

**Example response shape**
```json
{
  "query": "renewable energy investments in Germany",
  "total_results": 42,
  "requests_left": 998,
  "credits_used": 1,
  "results": [
    {
      "article": {
        "article_id": "string",
        "url": "https://example.com/article",
        "title": "string",
        "published_at": "2026-08-01T12:00:00Z",
        "summary": "string"
      },
      "chunk": {
        "chunk_id": "string",
        "chunk_index": 0,
        "text": "The most relevant excerpt matching the query"
      },
      "metadata": {
        "language": "english",
        "country": "US",
        "category": ["environment"],
        "sentiment": "neutral",
        "domain": "example.com",
        "site_type": "news"
      }
    }
  ]
}
```

Top-level response fields: `query` (echoes the submitted search), `total_results` (count of matching articles, capped at the requested limit), `results` (array of matches), `requests_left` (remaining API credit balance), and `credits_used` (credits consumed by this request). Each entry in `results` contains an `article` object (id, URL, title, publish timestamp, summary), a `chunk` object (the most relevant excerpt and its position within the article), and a `metadata` object (language, country, category tags, sentiment, source domain, and site type).

**Retrieving the full article text**
Search results include only a summary and the most relevant excerpt, not the full article body. To fetch the complete text of a specific article, use its `article_id` as a UUID in a Webz.io News API query, setting the timestamp to 30 days prior to the article's publish date:

```
GET https://api.webz.io/api/news?token=YOUR_TOKEN&q=uuid:ARTICLE_UUID&ts=YOUR_TIMESTAMP_30_DAYS_AGO
```


Webz.io News Search API

Talordata provides real-time structured SERP data from Google and major search engines, including Bing, Yandex, and DuckDuckGo.

## Overview
Talordata provides comprehensive documentation for its SERP API and proxy services, including quick starts, query parameters, integrations, and troubleshooting guides. The documentation offers detailed guides for each service type, demonstration cases, and seamless integration instructions.

## Authentication
The API requires authentication using an API token. Users need to obtain their API token to send requests to the Talordata SERP API.

## Base URL
The base URL for sending requests to the Talordata SERP API is `https://serpapi.talordata.net/serp/v1/request`.

## Endpoints

### 1. Send Your First Request
- **Request:**
    ```bash
    curl -X POST https://serpapi.talordata.net/serp/v1/request \
    -H "Content-Type: application/x-www-form-urlencoded" \
    -H "Authorization: Bearer token" \
    -d "engine=google" \
    -d "q=pizza" \
    -d "json=1"
    ```
- **Response:**
    ```json
    {
        "search_meta": { ... },
        "snack_pack": [ ... ],
        "knowledge": { ... },
        "organic": [ ... ]
    }
    ```

### 2. Code Example (Python)
- **Request:**
    ```python
    import http.client
    from urllib.parse import urlencode

    conn = http.client.HTTPSConnection("serpapi.talordata.net")
    params = {
        "url": "https://www.google.com/search",
        "q": "pizza",
        "json": "1"
    }
    payload = urlencode(params)
    headers = {
        'Authorization': 'Bearer token',
        'Content-Type': 'application/x-www-form-urlencoded'
    }
    conn.request("POST", "/request", payload, headers)
    res = conn.getresponse()
    data = res.read()
    print(data.decode("utf-8"))
    ```
- **Response:** JSON formatted structured data

### 3. Code Example (JavaScript)
- **Request:**
    ```javascript
    const axios = require('axios');
    const params = new URLSearchParams({
        url: 'https://www.google.com/search',
        q: 'pizza',
        json: '1'
    });
    const config = {
        method: 'post',
        url: 'https://serpapi.talordata.net/serp/v1/request',
        headers: {
            Authorization: 'Bearer token',
            'Content-Type': 'application/x-www-form-urlencoded'
        },
        data: params
    };
    axios.request(config)
        .then((response) => {
            console.log(JSON.stringify(response.data));
        })
        .catch((error) => {
            console.log(error);
        });
    ```
- **Response:** JSON formatted structured data

Users can send requests to obtain structured search engine results data using the Talordata SERP API and follow the provided examples to retrieve and process the data effectively.

Talordata

IPWhois.io is a REST API for retrieving detailed information about IPv4 and IPv6 addresses.

## Overview
The IP Geolocation API by IPWhois.io provides IP intelligence services, including geolocation, network, timezone, currency, and threat data. The API offers responses in JSON, XML, or CSV formats, designed for developers who require high performance, low latency, and production-grade reliability at scale. The platform operates on a proprietary Anycast network with globally distributed infrastructure and is built with optimized technology for maximum throughput and minimal overhead.

## Authentication
Authentication is not explicitly mentioned in the documentation. Users can access the API endpoints directly without requiring registration or entering specific data.

## Base URL
The base URL for the API endpoints is `http://ipwho.is/`.

## Endpoints
### Free Endpoint
#### Single IP Lookup
- **Request:** GET http://ipwho.is/{IP address}
  Example: `curl "http://ipwho.is/8.8.4.4"`
- **Response:**
```json
{
  "ip": "8.8.4.4",
  "success": true,
  "type": "IPv4",
  "continent": "North America",
  "country": "United States",
  "region": "California",
  "city": "Mountain View",
  ...
}
```

### Pro Endpoint
#### Features
- From $12.99/mo
- Unlimited requests/month
- Enhanced geolocation accuracy
- Native-language data
- Currency & Security Data (proxy, VPN, Tor)
- Bulk Endpoint (up to 100 IPs/call)
- Dashboard with usage analytics & API key management
- 99.99% uptime SLA & priority support

### Rate Limits
- Free Endpoint: 1,000 requests/day per client IP address
- Exceeding the rate limit results in HTTP 429 (Too Many Requests)
- Access restored automatically after 24 hours with Retry-After header

## Example Code
### JavaScript
```javascript
const ip = '8.8.8.8';
const url = 'https://ipwho.is/' + ip;
fetch(url)
  .then(res => res.json())
  .then(data => {
    console.log(`${data.country} ${data.flag.emoji}`);
    // Output: United States 🇺🇸
  });
```

### Python
```python
import requests

ip = '8.8.8.8'
url = f'https://ipwho.is/{ip}'
response = requests.get(url)
data = response.json()
print(data['country'], data['flag']['emoji'])
# Output: United States 🇺🇸
```

### Java
```java
import org.json.JSONObject;
import java.net.URI;
import java.net.http.*;
public class Main {
  public static void main(String[] args) throws Exception {
    var client = HttpClient.newHttpClient();
    var url = "https://ipwho.is/8.8.8.8";
    var request = HttpRequest.newBuilder()
      .uri(URI.create(url))
      .build();
    var body = client.send(request, HttpResponse.BodyHandlers.ofString()).body();
    var data = new JSONObject(body);
    System.out.println(data.getString("country") + " " + data.getJSONObject("flag").getString("emoji"));
    // Output: United States 🇺🇸
  }
}
```

IP Geolocation API by IPWhois.io

Managed screenshot automation service built for developers

## Overview
Screenshot Scout is a screenshot API designed for developers to obtain clean, production-ready screenshots of any URL with a single HTTP request. It offers a range of options for customizing screenshots, supports signed requests for secure URLs, provides official client libraries for multiple programming languages, and offers flexible pricing plans.

## Authentication
To access the Screenshot Scout API, users need to obtain an API key. The API key is required to authenticate requests and access the API endpoints.

## Base URL
The base URL for the Screenshot Scout API is `https://api.screenshotscout.com/v1`.

## Endpoints

### Take a Screenshot
#### Request
```bash
curl "https://api.screenshotscout.com/v1/capture?url=https://example.com/" \
-H "Authorization: Bearer YOUR_ACCESS_KEY"
```

#### Response
The API supports two response types:

1. **Binary Response**
```html
![A screenshot of example.com](https://api.screenshotscout.com/v1/capture?access_key=YOUR_ACCESS_KEY&url=https://example.com/)
```
Along with the binary response, the API returns the screenshot URL via the `Screenshot-Scout-Screenshot-URL` response header.

2. **JSON Response**
```json
{
  "screenshot_url": "https://cdn.screenshotscout.com/cdafae824c3a09d30a9660cd6473025b7ec7d9d8828722490502511c97076163.png"
}
```

### List of Available Screenshot Options
#### Request
```bash
curl "https://api.screenshotscout.com/v1/capture?access_key=YOUR_ACCESS_KEY&url=https://example.com/"
```

#### Response
A JSON object containing information about available screenshot options, including access key, signature, URL, format, response type, country settings, proxy settings, geolocation settings, and more.

Screenshot Scout

Web scraping, screenshots, and DNS tools via API.

# Geekflare API

## Overview
The Geekflare API provides detailed documentation for all available API endpoints, including request parameters, response formats, and code examples. Users can fork the Postman collection to explore and test every endpoint without writing any code.

## Authentication
Authentication details are not mentioned in the documentation.

## Base URL
All API endpoints use the base URL: [https://docs.geekflare.com/api/endpoint/reference](https://docs.geekflare.com/api/endpoint/reference)

## Endpoints

### 1. AI & Scraping
#### Endpoint: /ai-scraping
- **Example Request:**
```
GET /ai-scraping?url=https://example.com&proxy=US&follow_redirect=true&device=desktop
```
- **Example Response:**
```
{
    "content": "LLM-ready content",
    "screenshot": "https://example.com/screenshot.png",
    "pdf": "https://example.com/document.pdf"
}
```

### 2. Website Testing
#### Endpoint: /website-testing
- **Example Request:**
```
GET /website-testing?url=https://example.com&proxy=UK&follow_redirect=false&device=mobile
```
- **Example Response:**
```
{
    "performance": "Good",
    "broken_links": 0,
    "site_health": "Healthy"
}
```

### 3. DNS & Network
#### Endpoint: /dns-network
- **Example Request:**
```
GET /dns-network?url=https://example.com
```
- **Example Response:**
```
{
    "dns_records": [],
    "network_paths": [],
    "connectivity": "Stable"
}
```

### 4. Security
#### Endpoint: /security
- **Example Request:**
```
GET /security?url=https://example.com
```
- **Example Response:**
```
{
    "vulnerabilities": [],
    "certificate_info": {}
}
```

Geekflare API

Automate Document and PDF Workflows at Scale

### Overview
PDFGate is an API that allows users to manage the complete document lifecycle, from PDF generation to legally binding signatures. Users can generate PDFs from HTML and URLs, create envelopes for digital signatures, generate invoices, create contracts and agreements, collect data through fillable PDFs, and more. The API boasts a high level of performance and reliability, with over 720,000 documents processed monthly, 1,300+ users worldwide, and an average response time of 1.6 seconds.

### Authentication
Authentication details are not explicitly mentioned on the webpage. 

### Base URL
The base URL for PDFGate API is not provided on the webpage.

### Endpoints

#### Generate PDF
- **Request:**
  ```json
  {
    "url": "https://example.com/document"
  }
  ```
- **Response:**
  ```
  PDF file generated successfully.
  ```

#### Send Document for Signature
- **Request:**
  ```json
  {
    "document": "example_document.pdf",
    "recipients": ["recipient1@example.com", "recipient2@example.com"]
  }
  ```
- **Response:**
  ```
  Document sent for signatures successfully.
  ```

#### Generate Invoice
- **Request:**
  ```json
  {
    "invoice_details": {
      "amount": 100.00,
      "due_date": "2023-01-31"
    }
  }
  ```
- **Response:**
  ```
  Invoice generated successfully.
  ```

#### Create Contract
- **Request:**
  ```json
  {
    "contract_details": {
      "party1": "Company A",
      "party2": "Company B",
      "services": ["Service 1", "Service 2"]
    }
  }
  ```
- **Response:**
  ```
  Contract created successfully.
  ```

These are some of the endpoints provided by PDFGate API for managing documents, signatures, invoices, contracts, and more.

PDFGate

# AnyAPI Documentation

## Overview
AnyAPI is a powerful platform offering a collection of RESTful APIs to automate routine workflows. Developers can easily discover and connect their applications to a wide range of APIs available in the API Marketplace. AnyAPI.io provides various APIs such as Email Validation, Currency Exchange and Forex, Google Sheets integration, Holidays retrieval, IBAN Validation, PDF Invoice Generator, IP Geolocation, OpenGraph Image Generation, Phone Validation, Web Scraping, Website Screenshot, Sentiment Analysis, and VAT Number Validation.

## Authentication
Authentication methods are not explicitly mentioned in the extracted content.

## Base URL
The base URL for AnyAPI is https://anyapi.io

## Endpoints

### Email Validation
- **Endpoint:**
  - POST https://anyapi.io/email/validate
- **Example Request:**
  ```json
  {
      "email": "example@example.com"
  }
  ```
- **Example Response:**
  ```json
  {
      "valid": true,
      "domain": "example.com",
      "disposable": false
  }
  ```

### Currency Exchange and Forex
- **Endpoint:**
  - GET https://anyapi.io/currency/exchange
- **Example Request:**
  ```json
  {
      "base": "USD",
      "target": "EUR"
  }
  ```
- **Example Response:**
  ```json
  {
      "base": "USD",
      "target": "EUR",
      "rate": 0.85
  }
  ```

### Google Sheets
- **Endpoint:**
  - GET https://anyapi.io/google/sheets
- **Example Request:**
  ```json
  {
      "sheet_id": "abcd1234",
      "range": "Sheet1!A1:B2"
  }
  ```
- **Example Response:**
  ```json
  {
      "values": [["Name", "Age"], ["John Doe", 30]]
  }
  ```

### Holidays
- **Endpoint:**
  - GET https://anyapi.io/holidays
- **Example Request:**
  ```json
  {
      "country": "US",
      "year": 2022
  }
  ```
- **Example Response:**
  ```json
  {
      "holidays": [
          { "date": "2022-01-01", "name": "New Year's Day" },
          { "date": "2022-07-04", "name": "Independence Day" }
      ]
  }
  ```

### IBAN Validation
- **Endpoint:**
  - POST https://anyapi.io/iban/validate
- **Example Request:**
  ```json
  {
      "iban": "DE89370400440532013000"
  }
  ```
- **Example Response:**
  ```json
  {
      "valid": true,
      "country_code": "DE",
      "bank_code": "37040044"
  }
  ```

AnyAPI

Real-time SERP API for easy SERP scraping

## Overview
SearchApi is a real-time SERP API that provides structured JSON data from various search engines including Google, Bing, Baidu, YouTube, Amazon, and more. It offers features like proxy rotation, CAPTCHA solving, and JavaScript rendering to facilitate data retrieval for developers. With SearchApi, developers can access organic results, knowledge graphs, AI overviews, local packs, shopping results, and more through a single API call. The API supports geo-targeting across 20M+ locations with desktop, mobile, or tablet device emulation.

## Authentication
To use the SearchApi, authentication is required using a Bearer token provided as "YOUR_API_KEY".

## Base URL
The base URL for accessing the API is https://www.searchapi.io/api/v1/search

## Endpoints

### Google Search API
- **Description**: Retrieve Google search results including organic results, local results, knowledge graph, and related searches.
- **Endpoint**: `GET https://www.searchapi.io/api/v1/search?engine=google&q=coffee+shops&location=New+York`
- **Headers**: Authorization: Bearer YOUR_API_KEY
- **Example Response**:
```json
{
  "organic_results": [
    {
      "position": 1,
      "title": "Best Coffee Shops in NYC",
      "link": "https://example.com/nyc-coffee",
      "snippet": "Discover the top-rated coffee shops..."
    }
  ],
  "local_results": ["..."],
  "knowledge_graph": {"..."},
  "related_searches": ["..."]
}
```

### YouTube Transcripts API
- **Description**: Extract full video transcripts with timestamps for AI summarization and RAG pipelines.
- **Endpoint**: `GET https://www.searchapi.io/api/v1/search?engine=youtube_transcripts&video_id=VIDEO_ID`

### Google Maps API
- **Description**: Get local business listings with ratings, reviews, hours, and coordinates.
- **Endpoint**: `GET https://www.searchapi.io/api/v1/search?engine=google_maps&q=restaurants+near+me`

### Amazon Search API
- **Description**: Retrieve product listings with prices, ratings, and availability for e-commerce intelligence.
- **Endpoint**: `GET https://www.searchapi.io/api/v1/search?engine=amazon&q=wireless+headphones`

For more information on native integrations and pricing details, refer to the official SearchApi documentation.

SearchApi

Production grade IP intelligence at non-enterprise prices.

## Overview
IPWho is a fast, accurate, and developer-friendly IP Geolocation API that provides detailed information about IPv4 or IPv6 addresses. The API returns structured data including country, region, city, latitude, longitude, timezone, currency, dialing code, emoji flag, ASN number, and ISP. Responses are in a simple JSON structure that can be easily integrated into web, mobile, serverless, or backend systems. IPWho helps enrich IP addresses with geolocation and network intelligence, enabling personalization of user experiences, adding geographical context to analytics, detecting unusual login locations, and building geo-aware features.

## Authentication
Authentication details are not mentioned in the documentation.

## Base URL
The base URL for IPWho API is not specified in the documentation.

## Endpoints

### Single IP Lookup
Use this endpoint to fetch detailed information for one IP address.

#### Example Request
```http
GET /single-ip-lookup?ip=192.168.1.1
```

#### Example Response
```json
{
    "country": "United States",
    "region": "California",
    "city": "Los Angeles",
    "latitude": 34.0522,
    "longitude": -118.2437,
    "timezone": "Pacific Time",
    "currency": "USD",
    "dialing_code": "+1",
    "emoji_flag": "🇺🇸",
    "asn_number": "AS12345",
    "isp": "Example ISP"
}
```

### Bulk IP Lookup
Use this endpoint to lookup multiple IPs in a single request.

#### Example Request
```http
POST /bulk-ip-lookup
{
    "ips": ["192.168.1.1", "8.8.8.8"]
}
```

#### Example Response
```json
[
    {
        "ip": "192.168.1.1",
        "country": "United States",
        "region": "California",
        "city": "Los Angeles",
        "latitude": 34.0522,
        "longitude": -118.2437,
        "timezone": "Pacific Time",
        "currency": "USD",
        "dialing_code": "+1",
        "emoji_flag": "🇺🇸",
        "asn_number": "AS12345",
        "isp": "Example ISP"
    },
    {
        "ip": "8.8.8.8",
        "country": "United States",
        "region": "California",
        "city": "Mountain View",
        "latitude": 37.3861,
        "longitude": -122.0838,
        "timezone": "Pacific Time",
        "currency": "USD",
        "dialing_code": "+1",
        "emoji_flag": "🇺🇸",
        "asn_number": "AS15169",
        "isp": "Google LLC"
    }
]
```

### Field Filtering
Use this endpoint to filter responses and fetch only the data needed.

#### Example Request
```http
GET /field-filtering?ip=192.168.1.1&fields=country,city,latitude,longitude
```

#### Example Response
```json
{
    "country": "United States",
    "city": "Los Angeles",
    "latitude": 34.0522,
    "longitude": -118.2437
}
```

### Flexible Output Formats
Use this endpoint to choose the response formats.

#### Example Request
```http
GET /flexible-output-formats?ip=192.168.1.1&format=xml
```

#### Example Response
```xml
<ipInfo>
    <country>United States</country>
    <region>California</region>
    <city>Los Angeles</city>
    <latitude>34.0522</latitude>
    <longitude>-118.2437</longitude>
</ipInfo>
```

IPWho

Provides specific answers to questions using data and algorithms

## Overview
The WolframAlpha API offers several pre-built APIs that provide access to Wolfram|Alpha's capabilities. These APIs include the Full Results API, LLM API, Simple API, Short Answers API, Fast Query Recognizer API, Summary Boxes API, Instant Calculators API, and Spoken Results API.

## Authentication
To use the Wolfram|Alpha Full Results API, an AppID provided by Wolfram Research is required to identify the application or organization making the request.

## Base URL
The base URL for queries is: http://api.wolframalpha.com/v2/query

## Endpoints
1. **Full Results API Example Request:**
   - **Request:**
     ```http
     GET http://api.wolframalpha.com/v2/query?appid=DEMO&input=population%20of%20france
     ```
   - **Response:**
     ```xml
     <queryresult success="true" error="false">
         <pod title="Result">
             <subpod>
                 <plaintext>64.1 million people (world rank: 21st) (2014 estimate)</plaintext>
             </subpod>
         </pod>
     </queryresult>
     ```

2. **Full Results API Explorer Example Request:**
   - **Request:**
     ```http
     GET http://api.wolframalpha.com/v2/query?appid=YOUR_APP_ID&input=your_query_here
     ```
   - **Response:**
     ```json
     {
         "result": "Your result here"
     }
     ```

3. **Full Results API Reference Example Request:**
   - **Request:**
     ```http
     GET http://api.wolframalpha.com/v2/query?appid=YOUR_APP_ID&input=your_query_here
     ```
   - **Response:**
     ```xml
     <queryresult success="true" error="false">
         <pod title="Result">
             <subpod>
                 <plaintext>Your result here</plaintext>
             </subpod>
         </pod>
     </queryresult>
     ```

Feel free to explore the various parameters and customization options provided by the Wolfram|Alpha API.

WolframAlpha

## Overview
The Unplugg API provides forecasting for timeseries data related to energy consumption, temperature, or any other data with seasonality effects. It allows users to request forecasts based on provided timeseries data. Unplugg is designed for companies looking to implement forecasting algorithms in their energy solutions easily and efficiently. Users can access the API directly or try it out online.

## Authentication
Access to the Unplugg API is limited to valid access tokens. Users need to include the `x-access-token` header in their requests to authorize access.

## Base URL
The base URL for accessing the Unplugg API is `https://api.unplu.gg/`.

## Endpoints
### Requesting a Forecast
- **Endpoint**: `/forecast`
- **Example Request**:
  ```json
  POST https://api.unplu.gg/forecast
  Headers:
    Content-Type: application/json
    x-access-token: [YOUR-ACCESS-TOKEN]
  Body:
    {
      "data": [
        {"timestamp": 1466640000, "value": 0.27589941523037853},
        {"timestamp": 1466640900, "value": 0.4059699097648263},
        ...,
        {"timestamp": 1466641800, "value": 0.8376112426631153}
      ],
      "forecast_to": 1458136800,
      "callback": "http://your.domain/yourcallback"
    }
  ```
- **Example Response**:
  ```json
  200 OK
  {
    "forecast": [
      {"timestamp": 1458129600, "value": 58.6912515906},
      {"timestamp": 1458133200, "value": 30.5359068808},
      {"timestamp": 1458136800, "value": 36.7927021395},
      {"timestamp": 1458140400, "value": 48.7672586419}
    ],
    "job_id": "y0urJ0b1d"
  }
  ```

Unplugg

OpenAI-compatible gateway routing chat/completions across 500+ models with a free tier

## Overview
UnoRouter is a unified AI API platform that provides access to over 324 AI models from multiple providers through a single, intelligent endpoint. Users can build apps, run agents, and chat with characters using the same key, speed, and price.

## Authentication
UnoRouter uses a Bearer token for authentication. Users need to include their API key in the Authorization header when making requests to the API.

## Base URL
The base URL for UnoRouter API is `https://api.unorouter.com`

## Endpoints

### Get Started
- **Request**: 
    ```bash
    curl -X POST https://api.unorouter.com/v1/chat/completions \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -d { "model": "claude-3-5-sonnet-20240620", "messages": [ {"role": "user", "content": "Hello!"} ], "stream": true }
    ```
- **Response**: 
    ```
    Ready to Connect? Every AI model, one key. Build, chat, code, or tell stories. Your call.
    ```

### Subscription Plans
- **Starter Plan**:
  - **Price**: $20 per month
  - **API Credit**: $40 per month
  - **Benefits**: 
    - Delivered $10 each week
    - 2x the API credit you pay for
    - No request limit on free models
    - Automatic failover
  - **Endpoint**: OpenAI compatible endpoint
- **Pro Plan**:
  - **Price**: $50 per month
  - **API Credit**: $100 per month
  - **Benefits**: 
    - Delivered $25 each week
    - 2x the API credit you pay for
    - No request limit on free models
    - Automatic failover
  - **Endpoint**: OpenAI compatible endpoint
- **Scale Plan**:
  - **Price**: $100 per month
  - **API Credit**: $200 per month
  - **Benefits**: 
    - Delivered $50 each week
    - 2x the API credit you pay for
    - No request limit on free models
    - Automatic failover
  - **Endpoint**: OpenAI compatible endpoint

### Start a Conversation
Users can select a model and start chatting to test any AI model on UnoRouter.

For more detailed API documentation, users can visit the [Full API Docs](https://unorouter.com).

UnoRouter

YouTube transcript API for developers. Fetch captions from any video in production—no proxies, no IP blocks. Built for LLM, RAG, and MCP pipelines

## Overview
TranscriptFetch API provides video and audio transcripts that are structured for AI purposes. It allows users to convert content from platforms like YouTube, TikTok, Instagram, and podcasts into text that AI systems can read and cite.

### Authentication
TranscriptFetch API requires users to generate a key from the dashboard, which should be included in the Authorization header for making API calls.

### Base URL
Base URL: `https://transcriptfetch.com`

## Endpoints

### POST /api/v1/transcripts/video
- **Description**: Fetches timestamped video transcripts for any supported video URL.
- **Example Request**:
```shell
curl https://transcriptfetch.com/api/v1/transcripts/video \
-H "Authorization: Bearer tf_live_YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{ "video": "youtu.be/dQw4w9WgXcQ" }'
```
- **Example Response**:
```json
{
    "text": "Transcript text...",
    "timestamped_segments": [...],
    "usage": "Usage details..."
}
```

### POST /api/v1/transcripts/videoList
- **Description**: Lists videos from a channel or playlist.
- **Example Request**:
```json
{
    "since_video_id": "video_id",
    "page": 1
}
```
- **Example Response**:
```json
{
    "videos": [...],
    "pagination": {...}
}
```

### POST /api/v1/transcripts/channel
- **Description**: Retrieves podcast episodes from a link (Spotify, Apple Podcasts, or RSS).
- **Example Request**:
```json
{
    "episode_link": "episode_url"
}
```
- **Example Response**:
```json
{
    "podcast": "Podcast details...",
    "episode": "Episode details..."
}
```

### POST /api/v1/transcripts/video
- **Description**: Provides a way to reach transcripts through hosted MCP server and integration with tools like n8n, Make, and Zapier.
- **Example Request**:
```shell
https://transcriptfetch.com/mcp
```
- **Example Response**: MCP server details and integration steps.

This API offers additional endpoints and tools for various use cases, including fetching transcripts for different platforms and channels.

TranscriptFetch

This API generates customizable summaries of text and web pages using AI

### Overview
The Summarize Text with AI API provided by ApyHub offers an AI Summarizer tool that condenses text or web page URLs into shorter summaries. This tool is beneficial for quickly scanning through long articles, reports, product pages, or internal documents. The API caters to various workflows such as content triage, knowledge-base previews, research assistants, and reading-list digests.

### Authentication
Authentication requirements are not specified on the webpage.

### Base URL
Base URL: https://apyhub.com/utility/ai-summarize

### Endpoints
#### Text Summarization Endpoint
- **Request:**
```json
{
  "text": "Raw text content here",
  "summary_length": 3,
  "output_language": "English"
}
```

- **Response:**
```json
{
  "summary": "Shortened summary of the text content"
}
```

#### URL Summarization Endpoint
- **Request:**
```json
{
  "url": "https://example.com",
  "summary_length": 5,
  "output_language": "English"
}
```

- **Response:**
```json
{
  "summary": "Concise summary extracted from the provided URL content"
}
```

Summarize Text with AI

Free service to classify text as spam using ML

Spam Hunter

Face Detection, Face Recognition and Face Grouping

## Overview
SkyBiometry is a facial recognition API that allows users to detect and group faces in photos, save and tag faces, and train models for recognition purposes. The API provides endpoints for various functionalities such as detecting facial attributes, training models, and managing user namespaces.

## Authentication
The API supports authentication to ensure secure usage. 

## Base URL
The base URL for the API is https://skybiometry.com/api/v1/

## Endpoints

### Detect Faces in Photos
- **Endpoint:** POST /faces/detect
- **Request:**
```json
{
    "url": "https://example.com/photo.jpg"
}
```
- **Response:**
```json
{
    "groups": [
        {
            "uid": "123",
            "gid": "456",
            "tids": ["789"]
        }
    ],
    "photos": [
        {
            "pid": "abc",
            "url": "https://example.com/photo.jpg",
            "width": 800,
            "height": 600,
            "tags": [
                {
                    "tid": "789",
                    "recognizable": true,
                    "uid": {
                        "uid": "123",
                        "confidence": 90
                    }
                }
            ]
        }
    ]
}
```

### Train Models
- **Endpoint:** POST /faces/train
- **Request:**
```json
{
    "namespace": "default",
    "uid": "123",
    "photos": ["abc"]
}
```
- **Response:**
```json
{
    "created": [
        {
            "uid": "123",
            "training_set_size": 1,
            "last_trained": 1632327332,
            "training_in_progress": false
        }
    ]
}
```

### Check API Usage
- **Endpoint:** GET /account/limits
- **Response:**
```json
{
    "used": 100,
    "remaining": 400,
    "limit": 500,
    "reset_time": 1632330932,
    "reset_time_text": "2023-09-23 08:00:00 GMT",
    "namespace_used": 50,
    "namespace_remaining": 50,
    "namespace_limit": 100
}
```

SkyBiometry

## Overview
Roboflow Universe API provides access to a diverse range of functionalities related to Roboflow's Universe platform. It allows users to interact with data sets, models, and other resources hosted on the platform.

## Authentication
Authentication details are not explicitly mentioned in the extracted content. It's recommended to check the official Roboflow Universe documentation for authentication requirements.

## Base URL
The base URL for the Roboflow Universe API is https://universe.roboflow.com.

## Endpoints

### Example Request 1: Retrieve All Data Sets
- **Endpoint**: `{base_url}/api/datasets`
- **Method**: GET
- **Response**:
  ```json
  {
    "datasets": [
        {
            "id": 1,
            "name": "Example Dataset",
            "description": "This is an example dataset",
            "created_at": "2022-01-01T12:00:00Z"
        },
        {
            "id": 2,
            "name": "Another Dataset",
            "description": "A different dataset for testing",
            "created_at": "2022-02-01T08:00:00Z"
        }
    ]
  }
  ```

### Example Request 2: Get Model Details
- **Endpoint**: `{base_url}/api/models/{model_id}`
- **Method**: GET
- **Response**:
  ```json
  {
    "id": 1,
    "name": "Example Model",
    "type": "Object Detection",
    "accuracy": 0.85,
    "created_at": "2022-03-15T10:30:00Z"
  }
  ```

Roboflow Universe

NLP API to return probability that if text is toxic, obscene, insulting or threatening

## Overview
The Perspective API has grown from an experimental tool into a helpful solution for publishers and platforms, utilizing machine learning to enable online conversations. However, the service is officially sunsetting, with the API scheduled to end after 2026. Users are encouraged to explore new AI challenges as the capabilities evolve.

## Authentication
No specific authentication information provided.

## Base URL
- Base URL: https://perspectiveapi.com

## Endpoints

### Endpoint 1: Usage Requests
- **Request:**
  ```json
  {
    "requestType": "usage",
    "additionalDetails": "Specific information about the usage request",
    "timestamp": 1640995200
  }
  ```
- **Response:**
  ```json
  {
    "status": "success",
    "message": "Usage request successfully addressed.",
    "quotaStatus": "normal"
  }

### Endpoint 2: Quota Requests
- **Request:**
  ```json
  {
    "requestType": "quota",
    "additionalDetails": "Requirement for increased quota",
    "timestamp": 1640995200
  }
  ```
- **Response:**
  ```json
  {
    "status": "success",
    "message": "Quota request successfully addressed.",
    "newQuota": 1000
  }
  ```

### Endpoint 3: Submitting Requests
- **Request:**
  ```json
  {
    "requestType": "newRequest",
    "details": "Explanation of the new request",
    "timestamp": 1640995200
  }
  ```
- **Response:**
  ```json
  {
    "status": "success",
    "message": "New request submitted successfully.",
    "confirmationNumber": "ABC123"
  }

### Endpoint 4: Extended Access
- **Request:**
  ```json
  {
    "requestType": "extendAccess",
    "reason": "Justification for extending access",
    "timestamp": 1640995200
  }
  ```
- **Response:**
  ```json
  {
    "status": "error",
    "message": "Extension of access beyond 2026 is not possible.",
    "reason": "API service ending after 2026."
  }

Cross-Origin Resource Sharing (CORS)

What is an API key?

What is OAuth?