> For the complete documentation index, see [llms.txt](https://developers.oxylabs.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developers.oxylabs.io/products/pt-br/web-scraper-api/integration-methods/push-pull.md). # Push-Pull Descubra o método de integração Push-Pull para a Oxylabs Web Scraper API. Envie uma tarefa e depois consulte o endpoint de resultados mais tarde usando dados em formato JSON. Push-Pull é o método de integração recomendado para lidar de forma confiável com grandes volumes de dados. {% hint style="success" %} Visite o repositório GitHub da Oxylabs para um exemplo completo e funcional de [**integração Push-Pull em Python**](https://github.com/oxylabs/product-integrations/tree/master/scraper-apis/Python/push_pull). {% endhint %} Push-Pull é um método de integração assíncrono. Ao enviar a tarefa, você receberá prontamente uma `JSON` resposta contendo todos os detalhes da tarefa, incluindo parâmetros da tarefa, ID e URLs para download dos resultados e verificação de status. Assim que sua tarefa for processada, nós o atualizaremos por meio de uma `JSON` carga útil enviada ao seu servidor, se você forneceu uma [**callback**](#callback) URL. Os resultados permanecem disponíveis para recuperação por **pelo menos 24 horas** após a conclusão. Com Push-Pull, você pode enviar seus resultados diretamente para seu [**armazenamento em nuvem**](/products/pt-br/web-scraper-api/features/result-processing-and-storage/cloud-storage.md) (Google Cloud Storage, AWS S3, Alibaba Cloud OSS ou outro armazenamento compatível com S3). {% hint style="info" %} Se você preferir não configurar um serviço para notificações de callback recebidas, você pode simplesmente recuperar seus resultados periodicamente (*polling*). {% endhint %} Você também pode explorar como o Push-Pull funciona usando [**Postman**](/integrations/pt-br/web-scraper-api-integrations/postman.md). ## Job único ### Ponto de extremidade Este endpoint aceita apenas uma única `consulta` ou `URL` valor. ``` POST https://data.oxylabs.io/v1/queries ``` ### Entrada Forneça os parâmetros da tarefa em uma carga útil JSON como mostrado nos exemplos abaixo. Os exemplos em Python e PHP incluem comentários para clareza. {% tabs %} {% tab title="cURL" %} ```shell curl --user "USERNAME:PASSWORD" \ 'https://data.oxylabs.io/v1/queries' \ -H "Content-Type: application/json" \ -d '{"source": "universal", "url": "https://www.example.com", "geo_location": "United States", "callback_url": "https://your.callback.url", "storage_type": "s3", "storage_url": "s3://your.storage.bucket.url"}' ``` {% endtab %} {% tab title="Python" %} ```python import requests from pprint import pprint # Structure payload. payload = { "source": "universal", # Source you choose e.g. "universal" "url": "https://www.example.com", # Check the docs of the specific source to see whether you should use "url" or "query" "geo_location": "United States", # Some sources accept zip codes or coordinates #"render" : "html", # Uncomment if you want to render JavaScript within the page #"render" : "png", # Uncomment if you want to take a screenshot of a scraped web page #"parse" : True, # Check what sources support parsed data "callback_url": "https://your.callback.url", # Required if you use the callback listener "storage_type": "s3", "storage_url": "s3://your.storage.bucket.url" } # Get response. response = requests.request( 'POST', 'https://data.oxylabs.io/v1/queries', auth=('YOUR_USERNAME', 'YOUR_PASSWORD'), #Your credentials go here json=payload, ) # Print prettified response to stdout. pprint(response.json()) ``` {% endtab %} {% tab title="PHP" %} ```php 'universal', //Source you choose e.g. "universal" 'url' => 'https://www.example.com', // Check the docs of the specific source to see whether you should use "url" or "query" 'geo_location' => 'United States', //Some sources accept zip codes or coordinates //'render' => 'html', // Uncomment if you want to render JavaScript within the page //'render' => 'png', // Uncomment if you want to take a screenshot of a scraped web page //'parse' => TRUE, // Check what sources support parsed data 'callback_url' => 'https://your.callback.url', //Required if you use the callback listener 'storage_type' => 's3', 'storage_url' => 's3://your.storage.bucket.url' ); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, "https://data.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"); //Your credentials go here $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); ?> ``` {% 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() { { "source", "universal" }, { "url", "https://example.com" }, { "geo_location", "United States" }, { "callback_url", "https://your.callback.url" }, }; var client = new HttpClient(); Uri baseUri = new Uri("https://data.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", "callback_url": "https://your.callback.url", } jsonValue, _ := json.Marshal(payload) client := &http.Client{} request, _ := http.NewRequest("POST", "https://data.oxylabs.io/v1/queries", bytes.NewBuffer(jsonValue), ) request.Header.Add("Content-type", "application/json") 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"); jsonObject.put("callback_url", "https://your.callback.url"); 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://data.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" %} ```javascript import fetch from 'node-fetch'; const username = 'YOUR_USERNAME'; const password = 'YOUR_PASSWORD'; const body = { source: 'universal', url: 'https://www.example.com', geo_location: 'United States', callback_url: 'https://your.callback.url', }; const response = await fetch('https://data.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 API responderá com um JSON contendo as informações da tarefa, semelhante a isto: ```json { "callback_url": "https://your.callback.url", "client_id": 5, "context": [ {...} ], "created_at": "2026-09-03 00:00:01", "domain": "com", "geo_location": "United States", "id": "12345678900987654321", "limit": 10, "locale": null, "pages": 1, "parse": false, "parser_type": null, "parser_preset": null, "parsing_instructions": null, "browser_instructions": null, "render": null, "xhr": false, "markdown": false, "url": "https://www.example.com", "query": "", "source": "universal", "start_page": 1, "status": "pending", "storage_type": "s3", "storage_url": "YOUR_BUCKET_NAME/12345678900987654321.json", "aggregate_name": null, "subdomain": "www", "content_encoding": "utf-8", "updated_at": "2026-09-03 00:00:01", "user_agent_type": "desktop", "session_info": null, "statuses": [], "client_notes": null, "_links": [ { "rel": "self", "href": "http://data.oxylabs.io/v1/queries/12345678900987654321", "method": "GET" }, { "rel": "results", "href": "http://data.oxylabs.io/v1/queries/12345678900987654321/results", "method": "GET" }, { "rel": "results-content", "href_list": [ "http://data.oxylabs.io/v1/queries/12345678900987654321/results/1/content" ], "method": "GET" }, { "rel": "results-html", "href": "http://data.oxylabs.io/v1/queries/12345678900987654321/results?type=raw", "method": "GET" }, { "rel": "results-content-html", "href_list": [ "http://data.oxylabs.io/v1/queries/12345678900987654321/results/1/content?type=raw" ], "method": "GET" } ] } ``` ### Dicionário de dados A tabela abaixo descreve os campos retornados na resposta da tarefa. Para os parâmetros de entrada que você pode enviar, consulte a página de documentação da fonte que você está usando.
ChaveDescriçãoTipo
created_atA data e hora em que a tarefa foi criada.Cadeia de caracteres
client_idO ID numérico associado ao nome de usuário do cliente que está fazendo a solicitação.Cadeia de caracteres
client_notesObservações enviadas pelo cliente ao enviar uma tarefa.Cadeia de caracteres
content_encodingA codificação do conteúdo retornado. Defina-a em sua carga útil quando baixando imagens; ela é retornada na resposta da tarefa.Cadeia de caracteres
idO ID único da tarefa.Cadeia de caracteres
statusesOs códigos de status da tarefa de scraping ou parsing. Você pode ver os códigos de status descritos aqui.Inteiro
statusO status da tarefa. pendente significa que a tarefa ainda está sendo processada. concluído significa que concluímos a tarefa. com falha significa que encontramos erros ao tentar concluir a tarefa -- e desistimos dela.Cadeia de caracteres
subdomainO subdomínio do site.Cadeia de caracteres
updated_atA data e hora em que a tarefa foi atualizada pela última vez. Para tarefas que foram concluídas (status está concluído ou com falha), essa data e hora indica quando a tarefa foi concluída.Cadeia de caracteres
_linksA lista de links relacionados à entrada fornecida.Array JSON
_links:relO tipo do link. self A URL contém os metadados da tarefa, enquanto results a URL contém os resultados da tarefa.Cadeia de caracteres
_links:hrefA URL do recurso.Cadeia de caracteres
_links:href_listA lista de URLs do recurso, uma por página. Retornado em vez de href em entradas cujo rel começa com results-content. Veja Recuperar conteúdo da tarefa.Array JSON
_links:methodO método HTTP que deve ser usado para interagir com uma determinada URL.Cadeia de caracteres
## Callback O callback é uma `POST` solicitação que enviamos para sua máquina, informando que a tarefa de extração de dados foi concluída e fornecendo uma URL para baixar o conteúdo extraído. Isso significa que você não precisa [**verificar o status da tarefa**](#check-job-status) manualmente. Assim que os dados estiverem aqui, avisaremos você, e tudo o que você precisa fazer agora é [**recuperá-los**](#retrieve-job-content). ### Entrada {% tabs %} {% tab title="Python" %} ```python # This is a simple Sanic web server with a route listening for callbacks on localhost:8080. # It will print job results to stdout. import requests from pprint import pprint from sanic import Sanic, response AUTH_TUPLE = ('user', 'pass1') app = Sanic() # Define /job_listener endpoint that accepts POST requests. @app.route('/job_listener', methods=['POST']) async def job_listener(request): try: res = request.json links = res.get('_links', []) for link in links: if link['rel'] == 'results': # O Sanic é assíncrono, mas as requisições são síncronas, para aproveitar totalmente # as vantagens do Sanic, use aiohttp. res_response = requests.request( method='GET', url=link['href'], auth=AUTH_TUPLE, ) pprint(res_response.json()) break except Exception as e: print("Listener exception: {}".format(e)) return response.json(status=200, body={'status': 'ok'}) if __name__ == '__main__': app.run(host='0.0.0.0', port=8080) ``` {% endtab %} {% tab title="PHP" %} ```php ``` {% endtab %} {% tab title="C#" %} ```csharp using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using System; using System.Collections.Generic; using System.Net.Http; namespace OxyApiWeb { public class Callback { public Link[] _links { get; set; } } public class Link { public string rel { get; set; } public string href { get; set; } } public class Startup { private const string USERNAME = "YOUR_USERNAME"; private const string PASSWORD = "YOUR_PASSWORD"; public Startup(IConfiguration configuration) { Configuration = configuration; client = new HttpClient(); } public IConfiguration Configuration { get; } private HttpClient client; public void ConfigureServices(IServiceCollection services) { services.AddControllers(); } public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseRouting(); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapPost("/job_listener", async context => { var callback = await System.Text.Json.JsonSerializer.DeserializeAsync(context.Request.Body); foreach (var link in callback._links) { if (link.rel != "results") { continue; } var requestMessage = new HttpRequestMessage(HttpMethod.Get, new Uri(link.href)); 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); } var okMessage = new Dictionary() { { "message", "ok" } }; await System.Text.Json.JsonSerializer.SerializeAsync(context.Response.Body, okMessage); }); }); } } } ``` {% endtab %} {% tab title="Golang" %} ```go package main import ( "fmt" "github.com/labstack/echo/v4" "io/ioutil" "net/http" ) const Username = "YOUR_USERNAME" const Password = "YOUR_PASSWORD" type Callback struct { Links []Link `json:"_links"` } type Link struct { Href string `json:"href"` Method string `json:"method"` Rel string `json:"rel"` } func main() { echoServer := echo.New() client := &http.Client{} echoServer.POST("/job_listener", func(context echo.Context) error { callback := new(Callback) if err := context.Bind(callback); err != nil { return err } for _, link := range callback.Links { if link.Rel != "results" { continue } request, _ := http.NewRequest("GET", link.Href, nil, ) request.Header.Add("Content-type", "application/json") request.SetBasicAuth(Username, Password) response, _ := client.Do(request) responseText, _ := ioutil.ReadAll(response.Body) fmt.Println(string(responseText)) } return context.JSON(http.StatusOK, map[string]string { "status": "ok" }) }) echoServer.Logger.Fatal(echoServer.Start(":8080")) } ``` {% endtab %} {% tab title="Java" %} ```java package org.example; import okhttp3.*; import com.sun.net.httpserver.HttpServer; import org.apache.commons.io.IOUtils; import org.json.JSONArray; import org.json.JSONObject; import java.io.IOException; import java.io.OutputStream; import java.net.InetSocketAddress; import java.nio.charset.StandardCharsets; import java.util.Map; import java.util.Objects; 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() { HttpServer server = null; try { server = HttpServer.create(new InetSocketAddress("0.0.0.0", 8080), 0); } catch (IOException exception) { exception.printStackTrace(); System.exit(1); } 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(); server.createContext("/job_listener", exchange -> { var requestBody = IOUtils.toString(exchange.getRequestBody(), StandardCharsets.UTF_8); JSONObject requestJson = new JSONObject(requestBody); JSONArray links = requestJson.getJSONArray("_links"); for (var link : links.toList()) { var linkMap = (Map)link; if (!Objects.equals(linkMap.get("rel"), "results")) { continue; } var request = new Request.Builder() .url((String) linkMap.get("href")) .get() .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()); } } var responseJson = new JSONObject(); responseJson.put("status", "ok"); exchange.sendResponseHeaders(200, responseJson.toString().length()); OutputStream responseBody = exchange.getResponseBody(); responseBody.write(responseJson.toString().getBytes()); responseBody.flush(); responseBody.close(); exchange.close(); }); server.setExecutor(null); server.start(); } public static void main(String[] args) { new Thread(new Main()).start(); } } ``` {% endtab %} {% tab title="Node.js" %} ```javascript import express from 'express' import fetch from 'node-fetch'; const username = 'YOUR_USERNAME'; const password = 'YOUR_PASSWORD'; const app = express(); app.use(express.json()); app.post('/job_listener', async(request, response) => { for (const index in request.body._links) { const link = request.body._links[index]; if (link.rel !== 'results') { continue; } const jobResultResponse = await fetch(link.href, { method: 'get', headers: { 'Content-Type': 'application/json', 'Authorization': 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64'), } }); console.log(await jobResultResponse.json()); } response.send({status: 'ok'}); }); app.listen(8080); ``` {% endtab %} {% endtabs %} ### Saída ```json { "callback_url": "https://your.callback.url", "client_id": 5, "context": [ {...} ], "created_at": "2026-09-03 00:00:01", "domain": "com", "geo_location": "United States", "id": "12345678900987654321", "limit": 10, "locale": null, "pages": 1, "parse": false, "parser_type": null, "parser_preset": null, "parsing_instructions": null, "browser_instructions": null, "render": null, "xhr": false, "markdown": false, "url": "https://www.example.com", "query": "", "source": "universal", "start_page": 1, "status": "done", "storage_type": null, "storage_url": null, "aggregate_name": null, "subdomain": "www", "content_encoding": "utf-8", "updated_at": "2026-09-03 00:00:15", "user_agent_type": "desktop", "session_info": null, "statuses": [], "client_notes": null, "_links": [ { "rel": "self", "href": "http://data.oxylabs.io/v1/queries/12345678900987654321", "method": "GET" }, { "rel": "results", "href": "http://data.oxylabs.io/v1/queries/12345678900987654321/results", "method": "GET" }, { "rel": "results-content", "href_list": [ "http://data.oxylabs.io/v1/queries/12345678900987654321/results/1/content" ], "method": "GET" }, { "rel": "results-html", "href": "http://data.oxylabs.io/v1/queries/12345678900987654321/results?type=raw", "method": "GET" }, { "rel": "results-content-html", "href_list": [ "http://data.oxylabs.io/v1/queries/12345678900987654321/results/1/content?type=raw" ], "method": "GET" } ] } ``` ## Verificar status do job Se você forneceu uma URL de callback válida ao enviar seu job, notificaremos você quando ele for concluído enviando um `JSON` payload para a URL de callback especificada. Esse payload indicará que o job foi concluído e que seu status foi definido como `concluído`. No entanto, se você enviou um job sem usar [**o serviço de callback**](#callback), você pode verificar o status do job manualmente. Recupere a URL do `href` campo na `rel:self` seção da mensagem de resposta recebida após o envio do job. A URL para verificar o status do job será semelhante à seguinte: `http://data.oxylabs.io/v1/queries/12345678900987654321`. Consultar essa URL retornará as informações do job, incluindo seu status atual `status`. ### Ponto de extremidade ``` GET https://data.oxylabs.io/v1/queries/{id} ``` ### Entrada {% tabs %} {% tab title="cURL" %} ```bash curl --user "USERNAME:PASSWORD" \ 'https://data.oxylabs.io/v1/queries/12345678900987654321' ``` {% endtab %} {% tab title="Python" %} ```python import requests from pprint import pprint # Obter resposta do endpoint de estatísticas. response = requests.request( method='GET', url='https://data.oxylabs.io/v1/queries/12345678900987654321', auth=('user', 'pass1'), ) # Imprimir resposta JSON formatada em stdout. pprint(response.json()) ``` {% endtab %} {% tab title="PHP" %} ```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 JobId = "12345678900987654321"; const string Username = "YOUR_USERNAME"; const string Password = "YOUR_PASSWORD"; var client = new HttpClient(); Uri baseUri = new Uri("https://data.oxylabs.io"); client.BaseAddress = baseUri; var requestMessage = new HttpRequestMessage(HttpMethod.Get, $"/v1/queries/{JobId}"); 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 ( "fmt" "io/ioutil" "net/http" ) func main() { const JobId = "12345678900987654321" const Username = "YOUR_USERNAME" const Password = "YOUR_PASSWORD" client := &http.Client{} request, _ := http.NewRequest("GET", fmt.Sprintf("https://data.oxylabs.io/v1/queries/%s", JobId), nil, ) request.Header.Add("Content-type", "application/json") 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.*; public class Main implements Runnable { private static final String AUTHORIZATION_HEADER = "Authorization"; private static final String JOB_ID = "12345678900987654321"; public static final String USERNAME = "YOUR_USERNAME"; public static final String PASSWORD = "YOUR_PASSWORD"; public void run() { 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 request = new Request.Builder() .url(String.format("https://data.oxylabs.io/v1/queries/%s", JOB_ID)) .get() .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" %} ```javascript import fetch from 'node-fetch'; const jobId = '12345678900987654321'; const username = 'YOUR_USERNAME'; const password = 'YOUR_PASSWORD'; const response = await fetch(`https://data.oxylabs.io/v1/queries/${jobId}`, { method: 'get', headers: { 'Content-Type': 'application/json', 'Authorization': 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64'), } }); console.log(await response.json()); ``` {% endtab %} {% endtabs %} ### Saída Quando o job for concluído, a API responderá com as informações da consulta em formato JSON. O status do job será alterado para `concluído`, indicando que o job foi finalizado. Você pode recuperar o conteúdo consultando um dos links fornecidos. Além disso, a resposta incluirá o timestamp da última atualização do job, permitindo acompanhar seu tempo de processamento. ```json { "callback_url": null, "client_id": 5, "context": [ {...} ], "created_at": "2026-09-03 00:00:01", "domain": "com", "geo_location": "United States", "id": "12345678900987654321", "limit": 10, "locale": null, "pages": 1, "parse": false, "parser_type": null, "parser_preset": null, "parsing_instructions": null, "browser_instructions": null, "render": null, "xhr": false, "markdown": false, "url": "https://www.example.com", "query": "", "source": "universal", "start_page": 1, "status": "done", "storage_type": null, "storage_url": null, "aggregate_name": null, "subdomain": "www", "content_encoding": "utf-8", "updated_at": "2026-09-03 00:00:15", "user_agent_type": "desktop", "session_info": null, "statuses": [], "client_notes": null, "_links": [ { "rel": "self", "href": "http://data.oxylabs.io/v1/queries/12345678900987654321", "method": "GET" }, { "rel": "results", "href": "http://data.oxylabs.io/v1/queries/12345678900987654321/results", "method": "GET" }, { "rel": "results-content", "href_list": [ "http://data.oxylabs.io/v1/queries/12345678900987654321/results/1/content" ], "method": "GET" }, { "rel": "results-html", "href": "http://data.oxylabs.io/v1/queries/12345678900987654321/results?type=raw", "method": "GET" }, { "rel": "results-content-html", "href_list": [ "http://data.oxylabs.io/v1/queries/12345678900987654321/results/1/content?type=raw" ], "method": "GET" } ] } ``` ## Valores de status
ParâmetroDescrição
pendenteO job ainda está sendo processado e não foi concluído.
concluídoO job foi concluído. Você pode recuperar o resultado consultando a URL fornecida no href campo na rel:results seção, por exemplo: http://data.oxylabs.io/v1/queries/12345678900987654321/results.
com falhaHouve um problema com o job e não foi possível concluí-lo. Você não é cobrado por quaisquer com falha jobs.
## Recuperar conteúdo da tarefa Quando o job estiver pronto para ser recuperado, você pode usar a URL fornecida na resposta na `rel:results` seção. A URL terá a seguinte aparência: `http://data.oxylabs.io/v1/queries/12345678900987654321/results`. {% hint style="info" %} A `_links` As URLs são retornadas com um `http://` esquema. Substitua-o por `https://` antes de chamá-las, para que suas credenciais não sejam enviadas sem criptografia. {% endhint %} ### Endpoints Você pode recuperar diferentes tipos de resultado usando os seguintes endpoints: ``` GET https://data.oxylabs.io/v1/queries/{job_id}/results ``` ``` GET https://data.oxylabs.io/v1/queries/{job_id}/results?type=raw ``` ``` GET https://data.oxylabs.io/v1/queries/{job_id}/results?type=parsed ``` ``` GET https://data.oxylabs.io/v1/queries/{job_id}/results?type=png ``` ``` GET https://data.oxylabs.io/v1/queries/{job_id}/results?type=xhr ``` ``` GET https://data.oxylabs.io/v1/queries/{job_id}/results?type=markdown ``` 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, por exemplo: ``` GET https://data.oxylabs.io/v1/queries/{job_id}/results?type=parsed,raw ``` Para obter uma página isoladamente como conteúdo bruto, em vez de dentro de um objeto JSON, use o endpoint de conteúdo, onde `{n}` é o número da página, começando em `1`. Os mesmos `tipo` valores se aplicam. ``` GET https://data.oxylabs.io/v1/queries/{job_id}/results/{n}/content ``` ### Entrada Abaixo estão exemplos de código demonstrando como usar o `/results` endpoint: {% tabs %} {% tab title="cURL" %} ```shell curl --user "USERNAME:PASSWORD" \ 'https://data.oxylabs.io/v1/queries/12345678900987654321/results' ``` {% endtab %} {% tab title="Python" %} ```python import requests from pprint import pprint # Obter resposta do endpoint de estatísticas. response = requests.request( method='GET', url='https://data.oxylabs.io/v1/queries/12345678900987654321/results', auth=('user', 'pass1'), ) # Imprimir resposta JSON formatada em stdout. pprint(response.json()) ``` {% endtab %} {% tab title="PHP" %} ```php ``` {% endtab %} {% tab title="C#" %} ```csharp using System; using System.Net.Http; using System.Threading.Tasks; namespace OxyApi { class Program { static async Task Main() { const string JobId = "12345678900987654321"; const string Username = "YOUR_USERNAME"; const string Password = "YOUR_PASSWORD"; var client = new HttpClient(); Uri baseUri = new Uri("https://data.oxylabs.io"); client.BaseAddress = baseUri; var requestMessage = new HttpRequestMessage(HttpMethod.Get, $"/v1/queries/{JobId}/results"); 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 ( "fmt" "io/ioutil" "net/http" ) func main() { const JobId = "12345678900987654321" const Username = "YOUR_USERNAME" const Password = "YOUR_PASSWORD" client := &http.Client{} request, _ := http.NewRequest("GET", fmt.Sprintf("https://data.oxylabs.io/v1/queries/%s/results", JobId), nil, ) request.Header.Add("Content-type", "application/json") 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.*; public class Main implements Runnable { private static final String AUTHORIZATION_HEADER = "Authorization"; private static final String JOB_ID = "12345678900987654321"; public static final String USERNAME = "YOUR_USERNAME"; public static final String PASSWORD = "YOUR_PASSWORD"; public void run() { 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 request = new Request.Builder() .url(String.format("https://data.oxylabs.io/v1/queries/%s/results", JOB_ID)) .get() .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" %} ```javascript import fetch from 'node-fetch'; const jobId = '12345678900987654321'; const username = 'YOUR_USERNAME'; const password = 'YOUR_PASSWORD'; const response = await fetch(`https://data.oxylabs.io/v1/queries/${jobId}/results`, { method: 'get', headers: { 'Content-Type': 'application/json', 'Authorization': 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64'), } }); console.log(await response.json()); ``` {% endtab %} {% endtabs %} ### Saída Esta tabela explica o tipo de resultado padrão com base nos parâmetros incluídos no payload da solicitação da API. | Parâmetro Render | Parâmetro Parse | Parâmetro XHR | Saída padrão | | ---------------- | --------------- | ------------- | ------------ | | - | - | - | html | | `html` | - | - | html | | `html` | - | `true` | xhr | | `html` | `true` | `true` | parsed | | `png` | - | - | png | | - | `true` | - | parsed | | `html` | `true` | - | parsed | | `png` | `true` | - | png | Por padrão, o `/results` endpoint retorna apenas a saída padrão do seu payload. Para receber tipos de resultado adicionais, adicione o `tipo` parâmetro de consulta mostrado em [**Endpoints**](/products/pt-br/web-scraper-api/integration-methods/push-pull.md#endpoints) acima. Cada tipo solicitado é retornado como uma entrada separada no `results` array. Este é o [**vários tipos de resultado**](/products/pt-br/web-scraper-api/features/result-processing-and-storage/output-types/multi-format-output.md) recurso, e funciona da mesma forma em Push-Pull e [**Realtime**](/products/pt-br/web-scraper-api/integration-methods/realtime.md). Abaixo está uma resposta de exemplo do `/results` endpoint. Junto com `results`, ele retorna um `job` objeto contendo os mesmos detalhes do job descritos no [**Dicionário de dados**](#data-dictionary), abreviado aqui. Algumas fontes também retornam `_request`, `_response` e `session_info` em cada resultado. ```json { "results": [ { "content": "CONTENT", "created_at": "2026-09-03 00:00:01", "updated_at": "2026-09-03 00:00:15", "page": 1, "url": "https://www.example.com", "job_id": "12345678900987654321", "is_render_forced": false, "status_code": 200, "type": "raw", "_request": { "cookies": [], "headers": {...} }, "_response": { "cookies": [], "headers": {...} }, "session_info": { "expires_at": null, "id": null, "remaining": null } } ], "job": {...} } ``` Os resultados podem ser recuperados automaticamente sem verificar periodicamente o status do job configurando o [**Callback**](#callback) serviço. Para isso, especifique a URL de um servidor capaz de aceitar requisições HTTP(S) recebidas ao enviar um job. Quando nosso sistema concluir o job, ele irá `POST` enviar um payload JSON para a URL fornecida, e o serviço Callback fará o download dos resultados conforme descrito no [**exemplo de implementação de Callback**](#callback). ## Consulta em lote Scraper APIs suporta o envio de até 5.000 `consulta` ou `url` valores de parâmetro em uma única solicitação em lote. ### Ponto de extremidade ``` POST https://data.oxylabs.io/v1/queries/batch ``` O sistema processará cada `consulta` ou `url` enviado como um job separado. Se você fornecer uma URL de callback, receberá uma chamada separada para cada palavra-chave. Caso contrário, nossa resposta inicial conterá job `id`s para todas as palavras-chave. Por exemplo, se você enviar 50 palavras-chave, retornaremos 50 job `id`s. {% hint style="info" %} **IMPORTANTE:** Com `/batch` endpoint, você só pode enviar listas de `consulta`ou `url`valores de parâmetro (dependendo do `source` que você usar). Todos os demais parâmetros devem ter valores singulares. {% endhint %} ### Entrada Você precisa enviar os parâmetros da consulta como um payload JSON. Veja como enviar um job em lote: {% tabs %} {% tab title="cURL" %} ```shell curl --user "USERNAME:PASSWORD" \ 'https://data.oxylabs.io/v1/queries/batch' \ -H 'Content-Type: application/json' \ -d '@keywords.json' ``` {% endtab %} {% tab title="Python" %} ```python import requests import json from pprint import pprint # Obter payload do arquivo. with open('keywords.json', 'r') as f: payload = json.loads(f.read()) response = requests.request( 'POST', 'https://data.oxylabs.io/v1/queries/batch', auth=('user', 'pass1'), json=payload, ) # Imprimir resposta formatada. pprint(response.json()) ``` {% endtab %} {% tab title="PHP" %} ```php ``` {% endtab %} {% tab title="C#" %} ```csharp using System; using System.IO; using System.Net.Http; using System.Text; using System.Threading.Tasks; namespace OxyApi { class Program { static async Task Main() { const string Username = "YOUR_USERNAME"; const string Password = "YOUR_PASSWORD"; var content = File.ReadAllText(@"C:\path\to\keywords.json"); var client = new HttpClient(); var requestMessage = new HttpRequestMessage(HttpMethod.Post, new Uri("https://data.oxylabs.io/v1/queries/batch")); requestMessage.Content = new StringContent(content, Encoding.UTF8, "application/json"); var authenticationString = $"{Username}:{Password}"; var base64EncodedAuthenticationString = Convert.ToBase64String(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" "fmt" "io/ioutil" "net/http" "os" ) func main() { const Username = "YOUR_USERNAME" const Password = "YOUR_PASSWORD" content, err := os.ReadFile("keywords.json") if err != nil { panic(err) } client := &http.Client{} request, _ := http.NewRequest("POST", "https://data.oxylabs.io/v1/queries/batch", bytes.NewBuffer(content), ) request.Header.Add("Content-type", "application/json") request.SetBasicAuth(Username, Password) response, _ := client.Do(request) responseText, _ := ioutil.ReadAll(response.Body) fmt.Println(string(responseText)) } ``` {% endtab %} {% tab title="Java" %} ```java import okhttp3.*; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; 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() { Path filePath = Path.of("/path/to/keywords.json"); String jsonContent = null; try { jsonContent = Files.readString(filePath); } catch (IOException e) { throw new RuntimeException(e); } 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(jsonContent, mediaType); var request = new Request.Builder() .url("https://data.oxylabs.io/v1/queries/batch") .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" %} ```javascript import fetch from 'node-fetch'; import fs from 'fs' const username = 'YOUR_USERNAME'; const password = 'YOUR_PASSWORD'; const payload = fs.readFileSync('keywords.json').toString(); const response = await fetch('https://data.oxylabs.io/v1/queries/batch', { method: 'post', body: payload, headers: { 'Content-Type': 'application/json', 'Authorization': 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64'), } }); console.log(await response.json()); ``` {% endtab %} {% endtabs %} Você pode notar que o exemplo de código acima não explica como o payload JSON deve ser formatado e aponta para um arquivo JSON pronto. Abaixo está o conteúdo de `keywords.json` arquivo, contendo vários `consulta` valores de parâmetro: ```json { "query":[ "adidas", "nike", "reebok" ], "source": "google_shopping_search", "callback_url": "https://your.callback.url" } ``` ...e aqui está um `keywords.json` arquivo de entrada em lote, contendo várias URLs: ```json { "url":[ "https://example.com/url1.html", "https://example.com/url2.html", "https://example.com/url3.html" ], "source": "universal", "callback_url": "https://your.callback.url" } ``` ### Saída A API responderá com um objeto JSON, contendo as informações do job de cada job criado. A resposta será semelhante a esta: ```json { "queries": [ { "callback_url": "https://your.callback.url", "created_at": "2026-09-03 00:00:01", "id": "12345678900987654321", "query": "adidas", "source": "google_shopping_search", "status": "pending", {...} "_links": [ { "rel": "self", "href": "http://data.oxylabs.io/v1/queries/12345678900987654321", "method": "GET" }, { "rel": "results", "href": "http://data.oxylabs.io/v1/queries/12345678900987654321/results", "method": "GET" }, {...} ] }, { "callback_url": "https://your.callback.url", "created_at": "2026-09-03 00:00:01", "id": "12345678901234567890", "query": "nike", "source": "google_shopping_search", "status": "pending", {...} "_links": [ { "rel": "self", "href": "http://data.oxylabs.io/v1/queries/12345678901234567890", "method": "GET" }, { "rel": "results", "href": "http://data.oxylabs.io/v1/queries/12345678901234567890/results", "method": "GET" }, {...} ] }, { "callback_url": "https://your.callback.url", "created_at": "2026-09-03 00:00:01", "id": "01234567899876543210", "query": "reebok", "source": "google_shopping_search", "status": "pending", {...} "_links": [ { "rel": "self", "href": "http://data.oxylabs.io/v1/queries/01234567899876543210", "method": "GET" }, { "rel": "results", "href": "http://data.oxylabs.io/v1/queries/01234567899876543210/results", "method": "GET" }, {...} ] } ] } ``` {% hint style="info" %} Cada entrada carrega os mesmos campos que uma resposta de job única; `{...}` marca os campos omitidos aqui por brevidade. {% endhint %} ## Obter lista de endereços IP do Notifier Talvez você queira colocar os IPs que enviam mensagens de callback para você na lista de permissões ou obter a lista desses IPs para outros fins. Você pode fazer isso `GET`obtendo este endpoint: ### Ponto de extremidade ``` GET https://data.oxylabs.io/v1/info/callbacker_ips ``` ### Entrada Os exemplos de código abaixo mostram como você pode acessar o `/callbacker_ips` endpoint: {% tabs %} {% tab title="cURL" %} ```bash curl --user "USERNAME:PASSWORD" \ 'https://data.oxylabs.io/v1/info/callbacker_ips' ``` {% endtab %} {% tab title="Python" %} ```python import requests from pprint import pprint # Obtenha a resposta do endpoint de IPs de callback. response = requests.request( method='GET', url='https://data.oxylabs.io/v1/info/callbacker_ips', auth=('user', 'pass1'), ) # Imprimir resposta JSON formatada em stdout. pprint(response.json()) ``` {% endtab %} {% tab title="PHP" %} ```php ``` {% endtab %} {% tab title="C#" %} ```csharp using System; using System.Net.Http; using System.Threading.Tasks; namespace OxyApi { class Program { static async Task Main() { const string Username = "YOUR_USERNAME"; const string Password = "YOUR_PASSWORD"; var client = new HttpClient(); Uri baseUri = new Uri("https://data.oxylabs.io"); client.BaseAddress = baseUri; var requestMessage = new HttpRequestMessage(HttpMethod.Get, "/v1/info/callbacker_ips"); 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 ( "fmt" "io/ioutil" "net/http" ) func main() { const Username = "YOUR_USERNAME" const Password = "YOUR_PASSWORD" client := &http.Client{} request, _ := http.NewRequest("GET", "https://data.oxylabs.io/v1/info/callbacker_ips", nil, ) request.Header.Add("Content-type", "application/json") 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.*; 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() { 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 request = new Request.Builder() .url("https://data.oxylabs.io/v1/info/callbacker_ips") .get() .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" %} ```javascript import fetch from 'node-fetch'; const username = 'YOUR_USERNAME'; const password = 'YOUR_PASSWORD'; const response = await fetch('https://data.oxylabs.io/v1/info/callbacker_ips', { method: 'get', headers: { 'Content-Type': 'application/json', 'Authorization': 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64'), } }); console.log(await response.json()); ``` {% endtab %} {% endtabs %} ### Saída A API retornará a lista de IPs que fazem requisições de callback para o seu sistema: ```json { "ips": [ "x.x.x.x", "y.y.y.y" ] } ``` ## Scheduler Scheduler é um serviço que você pode usar para agendar trabalhos recorrentes de scraping. Ele estende a funcionalidade da integração Push-Pull e é melhor usado junto com a [**integração Cloud**](/products/pt-br/web-scraper-api/features/result-processing-and-storage/cloud-storage.md) funcionalidade. Visite esta página para aprender como usar o recurso Scheduler: {% content-ref url="/pages/6f5b6ae8a853bbb5d2fc0353c97d5a2df37b1ca6" %} [Scheduler](/products/pt-br/web-scraper-api/features/scheduler.md) {% endcontent-ref %} --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## 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, and the optional `goal` query parameter: ``` GET https://developers.oxylabs.io/products/pt-br/web-scraper-api/integration-methods/push-pull.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.