Custom Parser

Ve los pasos para un inicio rápido 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 bruto. Puedes generar analizadores automáticamente usando IA o escribirlos manualmente para escenarios avanzados.

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

Comenzando Generación de analizadores vía API Ajustes predefinidos de analizadores

Escribir instrucciones manualmente Lista de funciones de análisis

Inicio rápido

1. Genera un analizador

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 Oxylabs dashboard y selecciona Scraper APIs Playground en el menú lateral izquierdo.

Sigue los pasos mostrados en el video para generar un analizador:

Aquí están los mismos pasos mostrados en el video:

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

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

2. Guarda el analizador como un ajuste predefinido

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

Asigna el ajuste predefinido a un usuario API específico
Haz clic Guardar
Introduce el nombre del ajuste y la descripción (opcional)

Después de guardar el ajuste predefinido, puedes usarlo en solicitudes API.

3. Usa el analizador con solicitudes API

Para usar tu ajuste predefinido con Web Scraper API, envía una carga útil con el parser_preset parámetro establecido al nombre de tu ajuste. En los ejemplos de código abajo, reutilizamos el example_parser ajuste predefinido creado en pasos anteriores.

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"
    }'

import requests
from pprint import pprint


# Establece el ajuste predefinido del analizador a usar.
payload = {
    'source': 'universal',
    'url': 'https://example.com/',
    'parse': True,
    'parser_preset': 'example_parser'
}

# Obtén una respuesta.
response = requests.request(
    'POST',
    'https://realtime.oxylabs.io/v1/queries',
    auth=('USERNAME', 'PASSWORD'),
    json=payload
)

# Imprime la respuesta formateada en stdout.
pprint(response.json())

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

# Toda la cadena que envíes tiene que estar codificada en la URL.

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

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

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

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

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

Ejemplo de salida

{
  "results": [
    {
      "content": {
        "title": "Example Domain",
        "parse_status_code": 12000
      },
      "created_at": "2025-10-24 10:04:59",
      "updated_at": "2025-10-24 10:05:00",
      "page": 1,
      "url": "https://example.com/",
      "job_id": "7387428891226308609",
      "is_render_forced": false,
      "status_code": 200,
      "type": "parsed",
      "parser_type": "preset",
      "parser_preset": "example_parser"
    }
  ]
}

Obtener el contenido HTML de un trabajo analizado

También puedes recuperar el resultado HTML bruto añadiendo ?type=raw al final de la URL de recuperación del resultado. Lee más aquí.

AnteriorLista de instrucciones SiguienteComenzando

Última actualización hace 2 meses

¿Te fue útil?

Buenas tardes

hashtagInicio rápido

hashtag1. Genera un analizador

hashtag2. Guarda el analizador como un ajuste predefinido

hashtag3. Usa el analizador con solicitudes API

hashtagObtener el contenido HTML de un trabajo analizado

Inicio rápido

1. Genera un analizador

2. Guarda el analizador como un ajuste predefinido

3. Usa el analizador con solicitudes API

Obtener el contenido HTML de un trabajo analizado