Custom Parser

Consulta los pasos para empezar rápidamente con Oxylabs Custom Parser.

Custom Parser es una función gratuita de Web Scraper API que te permite crear lógica de análisis y procesamiento de datos que se ejecuta sobre un resultado HTML sin procesar. Puedes generar analizadores automáticamente usando IA o escribirlos manualmente para escenarios avanzados.

Para instrucciones y ejemplos detallados, consulta estas páginas:

Primeros pasos Generación de analizadores mediante API Presets de parser

Escribir instrucciones manualmente Lista de funciones de análisis

---

Inicio rápido

1. Genera un analizador

Te recomendamos empezar con nuestra herramienta impulsada por IA OxyCopilot que te permite generar scrapers y analizadores sin escribir código.

Para acceder a OxyCopilot, inicia sesión en el panel de Oxylabs y selecciona Scraper APIs Playground en el menú de la izquierda.

Sigue los pasos que se muestran en el video para generar un analizador:

Estos son los mismos pasos que se muestran en el video:

1. Introduce la(s) URL(s) que quieres extraer y analizar
2. Especifica cualquier parámetro como la renderización de JavaScript
3. Escribe un prompt que describa lo que quieres analizar
4. Ejecutar OxyCopilot

Cuando estés satisfecho con el analizador generado, carga las instrucciones.

2. Guarda el analizador como un preset

Puedes guardar fácilmente tus analizadores generados mediante OxyCopilot para usarlos más tarde. Consulta los pasos a continuación:

1. Asigna el preset a un usuario específico de la API
2. Haz clic en Guardar
3. Introduce el nombre del preset y la descripción (opcional)

Después de guardar el preset, puedes usarlo con solicitudes de API.

Un preset recién creado puede tardar hasta aproximadamente un minuto en estar disponible para trabajos de scraping tanto en Realtime como en Push-Pull. Hasta entonces, las solicitudes que lo referencian se rechazan con 400 - El parser_preset proporcionado no existe.

3. Usa el analizador con solicitudes de API

Para usar tu preset con Web Scraper API, envía un payload con el parser_preset parámetro establecido en el nombre de tu preset. En los ejemplos de código siguientes, estamos reutilizando el example_parser preset creado en los pasos anteriores.

cURL

curl 'https://realtime.oxylabs.io/v1/queries' \\
--user 'USERNAME:PASSWORD' \\
-H 'Content-Type: application/json' \\
-d '{
        "source": "universal",
        "url": "https://example.com/",
        "parse": true,
        "parser_preset": "example_parser"
    }'

Python

import requests
from pprint import pprint


# Set the parser preset to use.
payload = {
    'source': 'universal',
    'url': 'https://example.com/',
    'parse': True,
    'parser_preset': 'example_parser'
}

# Get a response.
response = requests.request(
    'POST',
    'https://realtime.oxylabs.io/v1/queries',
    auth=('USERNAME', 'PASSWORD'),
    json=payload
)

# Print prettified response to stdout.
pprint(response.json())

Node.js

const https = require("https");

const username = "USERNAME";
const password = "PASSWORD";
const body = {
    source: "universal",
    url: "https://example.com/",
    parse: true,
    parser_preset: "example_parser"
};

const options = {
    hostname: "realtime.oxylabs.io",
    path: "/v1/queries",
    method: "POST",
    headers: {
        "Content-Type": "application/json",
        Authorization:
            "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
    },
};

const request = https.request(options, (response) => {
    let data = "";

    response.on("data", (chunk) => {
        data += chunk;
    });

    response.on("end", () => {
        const responseData = JSON.parse(data);
        console.log(JSON.stringify(responseData, null, 2));
    });
});

request.on("error", (error) => {
    console.error("Error:", error);
});

request.write(JSON.stringify(body));
request.end();

HTTP

# The whole string you submit has to be URL-encoded.

https://realtime.oxylabs.io/v1/queries?source=universal&url=https%3A%2F%2Fexample.com%2F&parse=true&parser_preset=example_parser&access_token=12345abcde

PHP

<?php

$params = array(
    'source' => 'universal',
    'url' => 'https://example.com/',
    'parse' => true,
    'parser_preset' => 'example_parser'
);

$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, "USERNAME" . ":" . "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);

Golang

package main

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

func main() {
	const Username = "USERNAME"
	const Password = "PASSWORD"

	payload := map[string]interface{}{
		"source": "universal",
		"url": "https://example.com/",
		"parse": true,
		"parser_preset": "example_parser",
	}

	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))
}

C#

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 = "USERNAME";
            const string Password = "PASSWORD";

            var parameters = new {
                source = "universal",
                url = "https://example.com/",
                parse = true,
                parser_preset = "example_parser"
            };

            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);
        }
    }
}

Java

package org.example;

import okhttp3.*;
import org.json.JSONObject;
import java.util.concurrent.TimeUnit;

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

    public void run() {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("source", "universal");
        jsonObject.put("url", "https://example.com/");
        jsonObject.put("parse", true);
        jsonObject.put("parser_preset", "example_parser");

        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)
                .readTimeout(180, TimeUnit.SECONDS)
                .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()) {
            if (response.body() != null) {
                try (var responseBody = response.body()) {
                    System.out.println(responseBody.string());
                }
            }
        } catch (Exception exception) {
            System.out.println("Error: " + exception.getMessage());
        }

        System.exit(0);
    }

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

JSON

{
    "source": "universal",
    "url": "https://example.com/",
    "parse": true,
    "parser_preset": "example_parser"
}

Ejemplo de salida

{
  "results": [
    {
      "_request": {...},
      "_response": {...},
      "content": {
        "parse_status_code": 12000,
        "title": "Example Domain"
      },
      "created_at": "2026-09-08 08:26:26",
      "is_render_forced": false,
      "job_id": "7503005818992731137",
      "page": 1,
      "parser_preset": "example_parser",
      "parser_type": "preset",
      "session_info": {...},
      "status_code": 200,
      "type": "parsed",
      "updated_at": "2026-09-08 08:26:26",
      "url": "https://example.com/"
    }
  ]
}

Obtener el contenido HTML de un trabajo analizado

Un trabajo analizado también puede devolver el HTML sin procesar del que fue analizado: añade el tipo parámetro de consulta con raw (o parsed,raw para ambos) al endpoint Realtime o a la URL de resultados Push-Pull. Consulta Salida en múltiples formatos.