Introduction

TensorFlow Serving exposes models over network APIs, so PHP does not need to "embed TensorFlow" to use a served model. The practical question is which API to call. For most PHP applications, the REST interface is the simplest integration path. gRPC is also possible, but it requires more setup and is usually worth it only when you already depend on protobuf-based services.

Start with the Serving Endpoint

TensorFlow Serving usually exposes:

• REST on port 8501
• gRPC on port 8500

If your model is mounted as my_model, a REST prediction endpoint looks like this:

http://localhost:8501/v1/models/my_model:predict

The request body typically uses either:

• 'instances'
• 'inputs'

depending on how you want to format prediction data.

REST Is the Easiest Option from PHP

PHP can call the REST endpoint with cURL or any HTTP client. A small JSON prediction request looks like this:

1<?php
2
3$url = "http://localhost:8501/v1/models/my_model:predict";
4
5$payload = [
6    "instances" => [
7        [5.1, 3.5, 1.4, 0.2],
8        [6.7, 3.1, 4.7, 1.5],
9    ],
10];
11
12$ch = curl_init($url);
13curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
14curl_setopt($ch, CURLOPT_POST, true);
15curl_setopt($ch, CURLOPT_HTTPHEADER, ["Content-Type: application/json"]);
16curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
17
18$response = curl_exec($ch);
19
20if ($response === false) {
21    throw new RuntimeException(curl_error($ch));
22}
23
24curl_close($ch);
25
26echo $response, PHP_EOL;

That is enough for many real applications. The model is served elsewhere; PHP just sends shaped input data and parses the response.

Know the Model Signature

The serving API can only accept inputs that match the exported model signature. That means you need to know:

• input tensor name, if required by the signature
• expected data type
• expected shape
• output field names

If the model was exported with named inputs, a request may need to look like this instead:

1<?php
2
3$payload = [
4    "signature_name" => "serving_default",
5    "inputs" => [
6        "features" => [
7            [5.1, 3.5, 1.4, 0.2],
8            [6.7, 3.1, 4.7, 1.5],
9        ],
10    ],
11];

If the payload shape or names do not match the model signature, TensorFlow Serving returns an error even though the HTTP call itself succeeded.

Parse the JSON Response Safely

Prediction responses are usually JSON objects with a predictions field:

1<?php
2
3$decoded = json_decode($response, true);
4
5if (!isset($decoded["predictions"])) {
6    throw new RuntimeException("Unexpected response: " . $response);
7}
8
9foreach ($decoded["predictions"] as $prediction) {
10    var_dump($prediction);
11}

That keeps your application defensive. When model versions change, response shapes can change too, and explicit validation makes those changes easier to spot.

When gRPC Makes Sense

TensorFlow Serving's primary high-performance API is gRPC. PHP can use it, but the integration cost is higher:

• install the PHP gRPC extension
• generate client stubs from protobuf definitions
• manage typed request and response objects

That setup is reasonable if your organization already uses gRPC widely or if you need the same RPC patterns as other services. For many web applications, though, REST is simpler, easier to debug, and good enough.

Operational Concerns Matter

Connecting successfully is only the beginning. In production, you also need to think about:

• model versioning
• timeouts and retries
• authentication if the serving endpoint is not private
• request validation before prediction

A serving integration is just another network dependency. Treat it that way. Log failures clearly, set request timeouts, and do not assume every prediction call will succeed instantly.

Common Pitfalls

• Calling the wrong endpoint or wrong model name and assuming PHP integration is broken.
• Sending JSON that does not match the exported model signature.
• Treating REST and gRPC as interchangeable without planning for their different setup costs.
• Forgetting to validate the predictions field before using the response.
• Exposing the serving endpoint publicly without considering authentication and transport security.

Summary

• PHP usually connects to TensorFlow Serving most easily through the REST API.
• The critical requirement is matching the exported model signature exactly.
• cURL is enough for a working prediction client in many cases.
• gRPC is possible from PHP, but it is a heavier integration path.
• Production integrations still need timeouts, validation, version awareness, and security controls.