# Realtime

Realtime 是一种同步集成方法。它用于可靠地处理大规模数据提取任务，而无需你管理请求分发或基础设施。它 **需要保持连接打开** 直到任务成功完成或返回错误。 

## 任务提交

### 端点

用于任务提交的 Realtime API 端点是：

```
POST https://realtime.oxylabs.io/v1/queries
```

### 输入

请如下方示例所示，将任务参数作为 JSON 有效载荷提供。Python 和 PHP 示例包含注释以便说明。

{% tabs %}
{% tab title="cURL" %}

```shell
curl --user "USERNAME:PASSWORD" \
'https://realtime.oxylabs.io/v1/queries' \
-H "Content-Type: application/json" \
-d '{"source": "universal", "url": "https://example.com", "geo_location": "United States"}'
```

{% endtab %}

{% tab title="Python" %}

```python
import requests
from pprint import pprint


# 构造有效载荷。
payload = {
    "source": "universal", # 你选择的来源，例如 "universal"
    "url": "https://example.com", # 查看你所使用的特定来源文档，确认应使用 "url" 还是 "query"
    "geo_location": "United States", # 某些来源接受邮政编码和/或坐标
    #"render" : "html", # 如果你想在页面上渲染 JavaScript，请取消注释
    #"render" : "png", # 若要截取已抓取网页的截图，请取消注释
    #"parse" : true, # 查看哪些来源支持解析后的数据
}

# 获取响应。
response = requests.request(
    'POST',
    'https://realtime.oxylabs.io/v1/queries',
    auth=('YOUR_USERNAME', 'YOUR_PASSWORD'), # 您的凭据写在这里
    json=payload,
)

# 这里不会返回作业状态和结果 URL，而是会返回
# 带有结果的 JSON 响应。
pprint(response.json())
```

{% endtab %}

{% tab title="PHP" %}

```php
<?php

$params = array(
    'source' => 'universal', //你选择的来源，例如 "universal"
    'url' => 'https://example.com', // 查看你所使用的特定来源文档，确认应使用 "url" 还是 "query"
    'geo_location' => 'United States', //某些来源接受邮政编码或坐标
    //'render' : 'html', // 如果你想在页面内渲染 JavaScript，请取消注释
    //'render' : 'png', // 若要截取已抓取网页的截图，请取消注释
    //'parse' : TRUE, // 查看哪些来源支持解析后的数据
);

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, "https://realtime.oxylabs.io/v1/queries");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($params));
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_USERPWD, "YOUR_USERNAME" . ":" . "YOUR_PASSWORD"); // 您的凭据写在这里

$headers = array();
$headers[] = "Content-Type: application/json";
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$result = curl_exec($ch);
echo $result;

if (curl_errno($ch)) {
    echo 'Error:' . curl_error($ch);
}
curl_close ($ch);PHP
```

{% endtab %}

{% tab title="C#" %}

```csharp
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Json;
using System.Threading.Tasks;

namespace OxyApi
{
    class Program
    {
        static async Task Main()
        {
            const string Username = "YOUR_USERNAME";
            const string Password = "YOUR_PASSWORD";

            var parameters = new Dictionary<string, string>()
            {
                { "source", "universal" },
                { "url", "https://www.example.com" },
                { "geo_location", "United States" },
            };


            var client = new HttpClient();

            Uri baseUri = new Uri("https://realtime.oxylabs.io");
            client.BaseAddress = baseUri;

            var requestMessage = new HttpRequestMessage(HttpMethod.Post, "/v1/queries");
            requestMessage.Content = JsonContent.Create(parameters);

            var authenticationString = $"{Username}:{Password}";
            var base64EncodedAuthenticationString = Convert.ToBase64String(System.Text.ASCIIEncoding.UTF8.GetBytes(authenticationString));
            requestMessage.Headers.Add("Authorization", "Basic " + base64EncodedAuthenticationString);

            var response = await client.SendAsync(requestMessage);
            var contents = await response.Content.ReadAsStringAsync();

            Console.WriteLine(contents);
        }
    }
}
```

{% endtab %}

{% tab title="Golang" %}

```go
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	const Username = "YOUR_USERNAME"
	const Password = "YOUR_PASSWORD"

	payload := map[string]string{
		"source": "universal",
		"url": "https://example.com",
		"geo_location": "United States",
	}

	jsonValue, _ := json.Marshal(payload)

	client := &http.Client{}
	request, _ := http.NewRequest("POST",
		"https://realtime.oxylabs.io/v1/queries",
		bytes.NewBuffer(jsonValue),
	)

	request.SetBasicAuth(Username, Password)
	response, _ := client.Do(request)

	responseText, _ := ioutil.ReadAll(response.Body)
	fmt.Println(string(responseText))
}

```

{% endtab %}

{% tab title="Java" %}

```java
package org.example;

import okhttp3.*;
import org.json.JSONObject;

public class Main implements Runnable {
    private static final String AUTHORIZATION_HEADER = "Authorization";
    public static final String USERNAME = "YOUR_USERNAME";
    public static final String PASSWORD = "YOUR_PASSWORD";

    public void run() {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("source", "universal");
        jsonObject.put("url", "https://example.com");
        jsonObject.put("geo_location", "United States");

        Authenticator authenticator = (route, response) -> {
            String credential = Credentials.basic(USERNAME, PASSWORD);

            return response
                    .request()
                    .newBuilder()
                    .header(AUTHORIZATION_HEADER, credential)
                    .build();
        };

        var client = new OkHttpClient.Builder()
                .authenticator(authenticator)
                .build();

        var mediaType = MediaType.parse("application/json; charset=utf-8");
        var body = RequestBody.create(jsonObject.toString(), mediaType);
        var request = new Request.Builder()
                .url("https://realtime.oxylabs.io/v1/queries")
                .post(body)
                .build();

        try (var response = client.newCall(request).execute()) {
            assert response.body() != null;
            System.out.println(response.body().string());
        } catch (Exception exception) {
            System.out.println("Error: " + exception.getMessage());
        }

        System.exit(0);
    }

    public static void main(String[] args) {
        new Thread(new Main()).start();
    }
}

```

{% endtab %}

{% tab title="Node.js" %}

```shell
import fetch from 'node-fetch';

const username = 'YOUR_USERNAME';
const password = 'YOUR_PASSWORD';
const body = {
  source: 'universal',
  url: 'https://example.com',
  geo_location: 'United States'
};
const response = await fetch('https://realtime.oxylabs.io/v1/queries', {
  method: 'post',
  body: JSON.stringify(body),
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64'),
  }
});

console.log(await response.json());
```

{% endtab %}
{% endtabs %}

### 输出

Realtime API 支持在输出中包含以下结果类型：

* **HTML**：从目标网页抓取的原始 HTML 内容；
* **JSON**：从 HTML 内容解析出的结构化数据，以 JSON 格式呈现；
* **PNG**：渲染后页面的 PNG 格式 Base64 编码截图。
* **XHR：** [XHR 请求](/products/cn/web-scraper-api/features/result-processing-and-storage/output-types/capturing-network-requests-fetch-xhr.md) 在页面加载过程中发起的。
* **Markdown：** [Markdown](/products/cn/web-scraper-api/features/result-processing-and-storage/output-types/markdown-output.md) 网页的。

{% hint style="info" %}
你还可以检索 [多个结果类型](/products/cn/web-scraper-api/features/result-processing-and-storage/output-types/multi-format-output.md) ，并在单个 API 响应中返回。
{% endhint %}

此表根据 API 请求负载中包含的参数，说明默认结果类型及其他可用结果类型：

| 渲染参数   | 解析参数   | 默认输出 | 可用输出            |
| ------ | ------ | ---- | --------------- |
| -      | -      | html | html            |
| `html` | -      | html | html            |
| `png`  | -      | png  | html, png       |
| -      | `true` | json | html, json      |
| `html` | `true` | json | html, json      |
| `png`  | `true` | png  | html, json, png |

{% hint style="info" %}
Realtime API 始终返回默认输出。要获取其他可用输出，请使用 {[Push-Pull](https://developers.oxylabs.io/scraping-solutions/web-scraper-api/integration-methods/push-pull)} 集成方法。
{% endhint %}

#### 输出示例：

```json
{
  "results": [
    {
      "content": "<html>
      内容
      </html>",
      "created_at": "2024-06-26 13:13:06",
      "updated_at": "2024-06-26 13:13:07",
      "id": null,
      "page": 1,
      "url": "https://www.example.com/",
      "job_id": "12345678900987654321",
      "status_code": 200
    }
  ]
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://developers.oxylabs.io/products/cn/web-scraper-api/integration-methods/realtime.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.