# Realtime

Realtime é um método de integração síncrono. Ele é usado para lidar com tarefas de extração de dados em grande escala de forma confiável, sem exigir que você gerencie a distribuição de requisições ou a infraestrutura. Ele **requer manter a conexão aberta** até que a tarefa seja concluída com sucesso ou retorne um erro. 

## Envio da tarefa

### Endpoint

O endpoint da Realtime API para envio de tarefas é:

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

### Entrada

Forneça os parâmetros do job em um payload JSON como mostrado nos exemplos abaixo. Os exemplos em Python e PHP incluem comentários para maior clareza.

{% 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


# Estruture o payload.
payload = {
    "source": "universal", # Fonte que você escolhe, por exemplo, "universal"
    "url": "https://example.com", # Verifique a documentação da fonte específica que você está usando para ver se deve usar "url" ou "query"
    "geo_location": "United States", # Algumas fontes aceitam códigos postais e/ou coordenadas
    #"render" : "html", # Descomente se quiser renderizar JavaScript na página
    #"render" : "png", # Descomente se quiser tirar uma captura de tela de uma página web raspada
    #"parse" : true, # Verifique quais fontes oferecem suporte a dados processados
}

# Obtenha a response.
response = requests.request(
    'POST',
    'https://realtime.oxylabs.io/v1/queries',
    auth=('YOUR_USERNAME', 'YOUR_PASSWORD'), # Suas credenciais vão aqui
    json=payload,
)

# Em vez de uma resposta com status do job e URL dos resultados, isso retornará o
# Resposta JSON com resultados.
pprint(response.json())
```

{% endtab %}

{% tab title="PHP" %}

```php
<?php

$params = array(
    'source' => 'universal', //Fonte que você escolhe, por exemplo, "universal"
    'url' => 'https://example.com', // Verifique a documentação da fonte específica que você está usando para ver se deve usar "url" ou "query"
    'geo_location' => 'United States', //Algumas fontes aceitam CEP ou coordenadas
    //'render' : 'html', // Descomente se quiser renderizar JavaScript dentro da página
    //'render' : 'png', // Descomente se quiser tirar uma captura de tela de uma página web raspada
    //'parse' : TRUE, // Verifique quais fontes oferecem suporte a dados processados
);

$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"); // Suas credenciais vão aqui

$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://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 %}

### Saída

A Realtime API oferece estes tipos de resultado na saída:

* **HTML**: O conteúdo HTML bruto extraído da página da web de destino;
* **JSON**: Dados estruturados analisados a partir do conteúdo HTML, formatados em JSON;
* **PNG**: Captura de tela em Base64 da página renderizada no formato PNG.
* **XHR:** [Requisições XHR](/products/pt-br/web-scraper-api/features/result-processing-and-storage/output-types/capturing-network-requests-fetch-xhr.md) feitas أثناء carregar a página.
* **Markdown:** [Markdown](/products/pt-br/web-scraper-api/features/result-processing-and-storage/output-types/markdown-output.md) de uma página da web.

{% hint style="info" %}
Você também pode recuperar [vários tipos de resultado](/products/pt-br/web-scraper-api/features/result-processing-and-storage/output-types/multi-format-output.md) em uma única resposta da API.
{% endhint %}

Esta tabela explica o tipo de resultado padrão e outros tipos disponíveis com base nos parâmetros incluídos no payload da requisição da API:

| Parâmetro de renderização | Parâmetro de parse | Saída padrão | Saída disponível |
| ------------------------- | ------------------ | ------------ | ---------------- |
| -                         | -                  | 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" %}
A Realtime API sempre retorna a saída padrão. Para obter outras saídas disponíveis, use o método de integração {[Push-Pull](https://developers.oxylabs.io/scraping-solutions/web-scraper-api/integration-methods/push-pull)}.
{% endhint %}

#### Exemplo de saída:

```json
{
  "results": [
    {
      "content": "<html>
      CONTENT
      </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/pt-br/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.