# IPs de datacenter gratuitas

{% hint style="info" %}
La integración de las IPs de Datacenter gratuitas sigue el mismo proceso que nuestro estándar [**Datacenter Proxies**](https://developers.oxylabs.io/documentation/es/proxies/datacenter-proxies).
{% endhint %}

Después de registrarte en nuestra plataforma, ve a tu panel y crea un usuario de proxy. Este paso activa tu plan gratuito.

Después de crear un usuario de proxy, se te mostrará una ventana emergente con tu primera solicitud de prueba para recibir una IP aleatoria.\
Cópiala y cambia los `para crear tus credenciales de usuario API (` y `y` parámetros por tus credenciales de proxy:

```bash
curl -x dc.oxylabs.io:8000 -U "user-USERNAME:PASSWORD" https://ip.oxylabs.io/location
```

Encuentra más ejemplos de código en otros lenguajes de programación abajo:

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

```sh
curl -x dc.oxylabs.io:8000 -U "user-USERNAME:PASSWORD" https://ip.oxylabs.io/location 
```

{% endtab %}

{% tab title="Python" %}

```python
#pip install requests
import requests

username = 'USERNAME'
password = 'PASSWORD'
proxy = 'dc.oxylabs.io:8000'

proxies = {
   "https": ('https://user-%s:%s@%s' % (username, password, proxy))
}

response=requests.get("https://ip.oxylabs.io/location", proxies=proxies)

print(response.content)
```

{% endtab %}

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

<pre class="language-javascript"><code class="lang-javascript"><strong>//npm install axios
</strong><strong>const axios = require("axios");
</strong>const https = require("https");

const client = axios.create({
    httpsAgent: new https.Agent({
        rejectUnauthorized: false,
    }),
});
const username = 'USERNAME';
const password = 'PASSWORD'

client
    .get("https://ip.oxylabs.io/location", {
        proxy: {
            protocol: "https",
            host: "dc.oxylabs.io",
            port: 8000,
            auth: {
                username: `user-${username}`,
                password: password,
            },
        },
    })
    .then((res) => {
        console.log(res.data);
    })
    .catch((err) => console.error(err));

</code></pre>

{% endtab %}

{% tab title="PHP" %}

```php
<?php

$username = 'USERNAME';
$password = 'PASSWORD';
$proxy = 'dc.oxylabs.io:8000';
$target = 'https://ip.oxylabs.io/location';

$request = curl_init($target);
curl_setopt($request, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($request, CURLOPT_PROXY, $proxy);
curl_setopt($request, CURLOPT_PROXYUSERPWD, "user-$username:$password");
$responseBody = curl_exec($request);
$error = curl_error($request);
curl_close($request);

if ($responseBody !== false) {
    echo 'Response: ' . $responseBody;
} else {
    echo 'Failed to connect to proxy: ' . $error;
}
```

{% endtab %}

{% tab title="Go" %}

```go
package main

import (
	"fmt"
	"io"
	"net/http"
	"net/url"
)

func main() {
	username, password, entry := "USERNAME", "PASSWORD", "dc.oxylabs.io:8000"
	proxy, err := url.Parse(fmt.Sprintf("https://user-%s:%s@%s", username, password, entry))
	if err != nil {
		panic(err)
	}

	transport := &http.Transport{
		Proxy: http.ProxyURL(proxy),
	}
	client := &http.Client{Transport: transport}
	target := "https://ip.oxylabs.io/location"
	response, err := client.Get(target)
	if err != nil {
		panic(err)
	}
	defer response.Body.Close()

	body, err := io.ReadAll(response.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println("Response:")
	fmt.Println(string(body))
}
```

{% endtab %}

{% tab title="Java" %}

```java
package com.example;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Base64;

import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.HttpHost;

public class App {
    public static void main(String[] args) throws IOException, URISyntaxException {
        String target = "http://ip.oxylabs.io/location";
        String username = "USERNAME";
        String password = "PASSWORD";
        String proxy = "dc.oxylabs.io:8000";

        URI proxyURI = new URI(String.format("https://user-%s:%s@%s", username, password, proxy));

        String basicAuth = new String(
                Base64.getEncoder()
                        .encode(
                                proxyURI.getUserInfo().getBytes()));
        String response = Request.get(target)
                .addHeader("Proxy-Authorization", "Basic " + basicAuth)
                .viaProxy(HttpHost.create(proxyURI))
                .execute().returnContent().asString();

        System.out.println(response);
    }
}

```

{% endtab %}

{% tab title="C#" %}

```csharp
using System.Net;

// .NET currently does not support HTTPS proxies
var proxy = new WebProxy {
    Address = new Uri("dc.oxylabs.io:8000"),
    Credentials = new NetworkCredential(
        userName: "user-USERNAME",
        password: "PASSWORD"
    )
};

var httpClientHandler = new HttpClientHandler {Proxy = proxy};

using var client = new HttpClient(handler: httpClientHandler, disposeHandler: true);

var result = await client.GetStringAsync("https://ip.oxylabs.io/location");
Console.WriteLine(result);
```

{% endtab %}
{% endtabs %}

### Notas importantes:

**No se necesita especificar ubicación**:\
Las IPs gratuitas se asignan automáticamente y ofrecen opciones geográficas limitadas. **Las 5 IPs están ubicadas dentro de los Estados Unidos.** La selección de ubicación no está disponible, así que **no necesitas incluir parámetros de ubicación específicos** en tus solicitudes.

**Métodos de autenticación:**\
Puedes autenticarte usando usuario y contraseña o mediante la lista blanca de IPs. Independientemente del método que elijas, **se aplica la política de uso justo.**

**Política de uso justo:**\
Para garantizar la estabilidad de nuestros servicios y prevenir un posible abuso de tráfico, hemos implementado las siguientes limitaciones para las IPs de Datacenter gratuitas:

* **Límite de tráfico:** El plan gratuito incluye un límite colectivo de 5 GB de tráfico por usuario por mes en las 5 IPs. El tráfico se renueva mensualmente.
* **Sesiones concurrentes:** Estás limitado a 20 hilos concurrentes (sesiones) por usuario para asegurar un servicio estable y prevenir abusos.
* **IPs fijas:** Las IPs de Datacenter gratuitas son fijas y no se pueden reemplazar ni actualizar. Si necesitas IPs nuevas o diferentes, considera actualizar a un plan de pago.