¿Cómo envío una solicitud POST con PHP?

Método sin CURL con PHP5:

$url = 'http://server.com/path';
$data = array('key1' => 'value1', 'key2' => 'value2');

// use key 'http' even if you send the request to https://...
$options = array(
    'http' => array(
        'header'  => "Content-type: application/x-www-form-urlencoded\r\n",
        'method'  => 'POST',
        'content' => http_build_query($data)
    )
);
$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
if ($result === FALSE) { /* Handle error */ }

var_dump($result);

Consulte el manual de PHP para obtener más información sobre el método y cómo agregar encabezados, por ejemplo:

• stream_context_create: http://php.net/manual/en/function.stream-context-create.php

Podrías usar cURL:

<?php
//The url you wish to send the POST request to
$url = $file_name;

//The data you want to send via POST
$fields = [
    '__VIEWSTATE '      => $state,
    '__EVENTVALIDATION' => $valid,
    'btnSubmit'         => 'Submit'
];

//url-ify the data for the POST
$fields_string = http_build_query($fields);

//open connection
$ch = curl_init();

//set the url, number of POST vars, POST data
curl_setopt($ch,CURLOPT_URL, $url);
curl_setopt($ch,CURLOPT_POST, true);
curl_setopt($ch,CURLOPT_POSTFIELDS, $fields_string);

//So that curl_exec returns the contents of the cURL; rather than echoing it
curl_setopt($ch,CURLOPT_RETURNTRANSFER, true); 

//execute post
$result = curl_exec($ch);
echo $result;
?>

Utilizo la siguiente función para publicar datos usando curl. $ data es una matriz de campos para publicar (se codificará correctamente usando http_build_query). Los datos se codifican mediante application / x-www-form-urlencoded.

function httpPost($url, $data)
{
    $curl = curl_init($url);
    curl_setopt($curl, CURLOPT_POST, true);
    curl_setopt($curl, CURLOPT_POSTFIELDS, http_build_query($data));
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($curl);
    curl_close($curl);
    return $response;
}

@Edward menciona que http_build_query puede omitirse ya que curl codificará correctamente la matriz pasada al parámetro CURLOPT_POSTFIELDS, pero tenga en cuenta que en este caso los datos se codificarán utilizando multipart / form-data.

Utilizo esta función con API que esperan que los datos se codifiquen mediante application / x-www-form-urlencoded. Por eso utilizo http_build_query ().

Te recomiendo que uses el paquete de código abierto engullir que está completamente probado por unidades y utiliza las últimas prácticas de codificación.

Instalación de Guzzle

Vaya a la línea de comando en la carpeta de su proyecto y escriba el siguiente comando (asumiendo que ya tiene el administrador de paquetes compositor instalado). Si necesita ayuda para instalar Composer, deberías echar un vistazo aquí.

php composer.phar require guzzlehttp/guzzle

Uso de Guzzle para enviar una solicitud POST

El uso de Guzzle es muy sencillo, ya que utiliza una API ligera orientada a objetos:

// Initialize Guzzle client
$client = new GuzzleHttp\Client();

// Create a POST request
$response = $client->request(
    'POST',
    'http://example.org/',
    [
        'form_params' => [
            'key1' => 'value1',
            'key2' => 'value2'
        ]
    ]
);

// Parse the response object, e.g. read the headers, body, etc.
$headers = $response->getHeaders();
$body = $response->getBody();

// Output headers and body for debugging purposes
var_dump($headers, $body);

Me gustaría agregar algunas ideas sobre la respuesta basada en rizos de Fred Tanrikut. Sé que la mayoría de ellos ya están escritos en las respuestas anteriores, pero creo que es una buena idea mostrar una respuesta que los incluya a todos juntos.

Aquí está la clase que escribí para hacer solicitudes HTTP-GET / POST / PUT / DELETE basadas en curl, con respecto al cuerpo de la respuesta:

class HTTPRequester {
    /**
     * @description Make HTTP-GET call
     * @param       $url
     * @param       array $params
     * @return      HTTP-Response body or an empty string if the request fails or is empty
     */
    public static function HTTPGet($url, array $params) {
        $query = http_build_query($params); 
        $ch    = curl_init($url.'?'.$query);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HEADER, false);
        $response = curl_exec($ch);
        curl_close($ch);
        return $response;
    }
    /**
     * @description Make HTTP-POST call
     * @param       $url
     * @param       array $params
     * @return      HTTP-Response body or an empty string if the request fails or is empty
     */
    public static function HTTPPost($url, array $params) {
        $query = http_build_query($params);
        $ch    = curl_init();
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HEADER, false);
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $query);
        $response = curl_exec($ch);
        curl_close($ch);
        return $response;
    }
    /**
     * @description Make HTTP-PUT call
     * @param       $url
     * @param       array $params
     * @return      HTTP-Response body or an empty string if the request fails or is empty
     */
    public static function HTTPPut($url, array $params) {
        $query = \http_build_query($params);
        $ch    = \curl_init();
        \curl_setopt($ch, \CURLOPT_RETURNTRANSFER, true);
        \curl_setopt($ch, \CURLOPT_HEADER, false);
        \curl_setopt($ch, \CURLOPT_URL, $url);
        \curl_setopt($ch, \CURLOPT_CUSTOMREQUEST, 'PUT');
        \curl_setopt($ch, \CURLOPT_POSTFIELDS, $query);
        $response = \curl_exec($ch);
        \curl_close($ch);
        return $response;
    }
    /**
     * @category Make HTTP-DELETE call
     * @param    $url
     * @param    array $params
     * @return   HTTP-Response body or an empty string if the request fails or is empty
     */
    public static function HTTPDelete($url, array $params) {
        $query = \http_build_query($params);
        $ch    = \curl_init();
        \curl_setopt($ch, \CURLOPT_RETURNTRANSFER, true);
        \curl_setopt($ch, \CURLOPT_HEADER, false);
        \curl_setopt($ch, \CURLOPT_URL, $url);
        \curl_setopt($ch, \CURLOPT_CUSTOMREQUEST, 'DELETE');
        \curl_setopt($ch, \CURLOPT_POSTFIELDS, $query);
        $response = \curl_exec($ch);
        \curl_close($ch);
        return $response;
    }
}

Mejoradas

• Usando http_build_query para obtener la cadena de consulta de una matriz de solicitud (también puede usar la matriz en sí, por lo tanto, consulte: http://php.net/manual/en/function.curl-setopt.php)
• Devolver la respuesta en lugar de repetirla. Por cierto, puedes evitar el regreso quitando la línea. curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, verdadero);. Después de eso, el valor de retorno es un booleano (verdadero = la solicitud fue exitosa, de lo contrario se produjo un error) y la respuesta se repite. Ver: http://php.net/en/manual/function.curl-exec.php
• Limpiar el cierre de la sesión y la eliminación del controlador de curl mediante el uso de curl_close. Ver: http://php.net/manual/en/function.curl-close.php
• Usando valores booleanos para el curl_setopt función en lugar de usar cualquier número. (Sé que cualquier número que no sea igual a cero también se considera verdadero, pero el uso de verdadero genera un código más legible, pero esa es solo mi opinión)
• Capacidad para realizar llamadas HTTP-PUT / DELETE (útil para pruebas de servicio RESTful)

Ejemplo de uso

$response = HTTPRequester::HTTPGet("http://localhost/service/foobar.php", array("getParam" => "foobar"));

PUBLICAR

$response = HTTPRequester::HTTPPost("http://localhost/service/foobar.php", array("postParam" => "foobar"));

PUT

$response = HTTPRequester::HTTPPut("http://localhost/service/foobar.php", array("putParam" => "foobar"));

BORRAR

$response = HTTPRequester::HTTPDelete("http://localhost/service/foobar.php", array("deleteParam" => "foobar"));

Pruebas

También puede hacer algunas pruebas de servicio interesantes usando esta clase simple.

class HTTPRequesterCase extends TestCase {
    /**
     * @description test static method HTTPGet
     */
    public function testHTTPGet() {
        $requestArr = array("getLicenses" => 1);
        $url        = "http://localhost/project/req/licenseService.php";
        $this->assertEquals(HTTPRequester::HTTPGet($url, $requestArr), '[{"error":false,"val":["NONE","AGPL","GPLv3"]}]');
    }
    /**
     * @description test static method HTTPPost
     */
    public function testHTTPPost() {
        $requestArr = array("addPerson" => array("foo", "bar"));
        $url        = "http://localhost/project/req/personService.php";
        $this->assertEquals(HTTPRequester::HTTPPost($url, $requestArr), '[{"error":false}]');
    }
    /**
     * @description test static method HTTPPut
     */
    public function testHTTPPut() {
        $requestArr = array("updatePerson" => array("foo", "bar"));
        $url        = "http://localhost/project/req/personService.php";
        $this->assertEquals(HTTPRequester::HTTPPut($url, $requestArr), '[{"error":false}]');
    }
    /**
     * @description test static method HTTPDelete
     */
    public function testHTTPDelete() {
        $requestArr = array("deletePerson" => array("foo", "bar"));
        $url        = "http://localhost/project/req/personService.php";
        $this->assertEquals(HTTPRequester::HTTPDelete($url, $requestArr), '[{"error":false}]');
    }
}

Hay otro método CURL si vas por ese camino.

Esto es bastante sencillo una vez que entiendes cómo funciona la extensión PHP curl, combinando varios indicadores con llamadas setopt (). En este ejemplo, tengo una variable $ xml que contiene el XML que he preparado para enviar; voy a publicar el contenido de eso en el método de prueba del ejemplo.

$url = 'http://api.example.com/services/xmlrpc/';
$ch = curl_init($url);

curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $xml);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
//process $response

Primero inicializamos la conexión, luego configuramos algunas opciones usando setopt (). Estos le dicen a PHP que estamos haciendo una solicitud de publicación y que estamos enviando algunos datos con ella, proporcionando los datos. La bandera CURLOPT_RETURNTRANSFER le dice a curl que nos dé la salida como el valor de retorno de curl_exec en lugar de generarla. Luego hacemos la llamada y cerramos la conexión; el resultado es $ respuesta.

Si por casualidad está utilizando Wordpress para desarrollar su aplicación (en realidad es una forma conveniente de obtener autorización, páginas de información, etc. incluso para cosas muy simples), puede usar el siguiente fragmento:

$response = wp_remote_post( $url, array('body' => $parameters));

if ( is_wp_error( $response ) ) {
    // $response->get_error_message()
} else {
    // $response['body']
}

Utiliza diferentes formas de realizar la solicitud HTTP real, según lo que esté disponible en el servidor web. Para obtener más detalles, consulte la Documentación de la API HTTP.

Si no desea desarrollar un tema o complemento personalizado para iniciar el motor de Wordpress, puede hacer lo siguiente en un archivo PHP aislado en la raíz de wordpress:

require_once( dirname(__FILE__) . '/wp-load.php' );

// ... your code

No mostrará ningún tema ni generará ningún HTML, ¡simplemente piratee con las API de Wordpress!

Otra alternativa del sin rizos método anterior es usar el nativo stream funciones:

• stream_context_create():

  Crea y devuelve un contexto de flujo con las opciones proporcionadas en opciones Preestablecido.

• stream_get_contents():

  Idéntico a file_get_contents(), excepto que stream_get_contents() opera en una corriente ya abierta recurso y devuelve el contenido restante en una cadena, hasta longitud máxima bytes y comenzando en el especificado compensar.

Una función POST con estos puede ser simplemente así:

<?php

function post_request($url, array $params) {
  $query_content = http_build_query($params);
  $fp = fopen($url, 'r', FALSE, // do not use_include_path
    stream_context_create([
    'http' => [
      'header'  => [ // header array does not need '\r\n'
        'Content-type: application/x-www-form-urlencoded',
        'Content-Length: ' . strlen($query_content)
      ],
      'method'  => 'POST',
      'content' => $query_content
    ]
  ]));
  if ($fp === FALSE) {
    return json_encode(['error' => 'Failed to get contents...']);
  }
  $result = stream_get_contents($fp); // no maxlength/offset
  fclose($fp);
  return $result;
}

Aquí está usando solo un comando sin cURL. Súper simple.

echo file_get_contents('https://www.server.com', false, stream_context_create([
    'http' => [
        'method' => 'POST',
        'header'  => "Content-type: application/x-www-form-urlencoded",
        'content' => http_build_query([
            'key1' => 'Hello world!', 'key2' => 'second value'
        ])
    ]
]));

La mejor forma de enviar GET or POST solicitudes con PHP es como a continuación:

<?php
    $r = new HttpRequest('http://example.com/form.php', HttpRequest::METH_POST);
    $r->setOptions(array('cookies' => array('lang' => 'de')));
    $r->addPostFields(array('user' => 'mike', 'pass' => 's3c|r3t'));

    try {
        echo $r->send()->getBody();
    } catch (HttpException $ex) {
        echo $ex;
    }
?>

El código está tomado de la documentación oficial aquí. http://docs.php.net/manual/da/httprequest.send.php

Estaba buscando un problema similar y encontré un mejor enfoque para hacer esto. Así que aquí va.

Simplemente puede poner la siguiente línea en la página de redirección (digamos page1.php).

header("Location: URL", TRUE, 307); // Replace URL with to be redirected URL, e.g. final.php

Necesito esto para redirigir las solicitudes POST para RESTO Llamadas a API. Esta solución puede redirigir con datos de publicación, así como con valores de encabezado personalizados.

Esta es el enlace de referencia.

Prueba PEAR's HTTP_Request2 paquete para enviar fácilmente solicitudes POST. Alternativamente, puede usar las funciones curl de PHP o usar un PHP contexto de la transmisión.

HTTP_Request2 también permite burlarse del servidor, para que pueda realizar pruebas unitarias de su código fácilmente

[Editar]: ignore, no está disponible en php ahora.

Hay uno más que puedes usar

<?php
$fields = array(
    'name' => 'mike',
    'pass' => 'se_ret'
);
$files = array(
    array(
        'name' => 'uimg',
        'type' => 'image/jpeg',
        'file' => './profile.jpg',
    )
);

$response = http_post_fields("http://www.example.com/", $fields, $files);
?>

Haga clic aquí para más detalles

Según la respuesta principal, esto es lo que uso:

function do_post($url, $params) {
    $options = array(
        'http' => array(
            'header'  => "Content-type: application/x-www-form-urlencoded\r\n",
            'method'  => 'POST',
            'content' => $params
        )
    );
    $result = file_get_contents($url, false, stream_context_create($options));
}

Ejemplo de uso:

do_post('https://www.google-analytics.com/collect', 'v=1&t=pageview&tid=UA-xxxxxxx-xx&cid=abcdef...');

Prefiero éste:

function curlPost($url, $data = NULL, $headers = []) {
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
    curl_setopt($ch, CURLOPT_TIMEOUT, 5); //timeout in seconds
    curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
    curl_setopt($ch, CURLOPT_ENCODING, 'identity');

    
    if (!empty($data)) {
        curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
    }

    if (!empty($headers)) {
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    }

    $response = curl_exec($ch);
    if (curl_error($ch)) {
        trigger_error('Curl Error:' . curl_error($ch));
    }

    curl_close($ch);
    return $response;
}

Ejemplo de uso:

$response=curlPost("http://my.url.com", ["myField1"=>"myValue1"], ["myFitstHeaderName"=>"myFirstHeaderValue"]);