Artax Laravel Package

Product Decisions This Supports

• Build vs. Buy: Buy—Leverage amphp/artax (or its successor, amphp/http-client) to avoid reinventing an async HTTP client from scratch, especially for high-concurrency, low-latency use cases. The package eliminates dependency on ext/curl, reducing server complexity and improving portability.
• Roadmap: Prioritize migration to amphp/http-client (the maintained successor) if adopting this package, as artax is deprecated. Use this as a temporary or legacy solution only.
• Feature Enablement:
  • High-performance scraping/crawling: Async parallel requests reduce latency for large-scale data collection (e.g., price comparison tools, SEO audits).
  • Microservices communication: Lightweight, non-blocking HTTP calls between services in a PHP-based architecture (e.g., Laravel + Amp).
  • Real-time systems: Stream large responses (e.g., file downloads, logs) without memory overload via chunked transfers.
  • Compliance/standards: Strict HTTP/1.1 adherence for APIs requiring RFC compliance (e.g., financial systems, government integrations).
• Use Cases:
  • Replacing cURL or Guzzle in legacy systems where async I/O is critical.
  • Building custom proxies or load balancers with fine-grained control over HTTP flows.
  • Integrating with legacy systems that require raw TCP socket manipulation (e.g., custom protocols over HTTP).

When to Consider This Package

• Adopt if:
  • You need asynchronous, non-blocking HTTP requests in PHP (e.g., for event loops like Amp, ReactPHP, or Swoole).
  • Your use case cannot use ext/curl (e.g., Docker containers without extensions, strict dependency policies).
  • You require HTTP/1.1 compliance with manual control over headers, redirects, or proxies.
  • You’re processing large responses (streaming bodies) or high concurrency (thousands of parallel requests).
  • You’re already using the Amp ecosystem (e.g., amphp/amp, amphp/socket) and want consistency.
• Look elsewhere if:
  • You need HTTP/2 support (use amphp/http-client or Guzzle).
  • You require active maintenance (this package is deprecated; migrate to amphp/http-client).
  • Your stack uses synchronous frameworks (e.g., plain Laravel without async extensions).
  • You need simpler APIs (e.g., Guzzle or Symfony HTTP Client for most REST use cases).
  • You’re targeting PHP 8.2+ with modern async features (e.g., Fibers; amphp/http-client is more aligned with future-proofing).

How to Pitch It (Stakeholders)

For Executives:

"We can reduce latency and scale HTTP requests in our [X system] by adopting amphp/artax (or its successor), enabling parallel, non-blocking calls without cURL dependencies. This aligns with our goal to [improve performance/cost-efficiency] while maintaining compliance with HTTP/1.1 standards. The package is battle-tested in high-concurrency environments and integrates seamlessly with our existing [Amp/async] infrastructure. Migration to the maintained amphp/http-client is straightforward, ensuring long-term viability."

For Engineering:

*"This package offers a lightweight, async HTTP client built on Amp’s event loop, ideal for:

• High-throughput scraping/crawling (e.g., [Project Y]).
• Microservice communication (e.g., [Service Z] → [Service A]).
• Streaming large responses without memory bloat. Key advantages: ✅ No ext/curl dependency (simpler deployments). ✅ Fine-grained control over HTTP/1.1 (headers, proxies, redirects). ✅ Proven stability (used in production by Amp ecosystem). Action: Evaluate for [use case], then migrate to amphp/http-client for maintenance. Avoid for HTTP/2 or sync-only workflows."*

For Developers:

*"If you’re working on async PHP (Amp/ReactPHP/Swoole) and need a reliable, low-level HTTP client, artax is a solid choice—but use amphp/http-client instead. Key perks:

• Async by design: Fire-and-forget requests with parallel execution.
• Memory-efficient: Streams responses; handles gzip/cookies/proxies.
• No cURL: Pure PHP implementation (good for Docker/lightweight setups). Trade-offs:
• Deprecated (but stable for now).
• HTTP/1.1 only (no HTTP/2). Example:

$client = new Artax\Client();
$response = yield $client->request('GET', 'https://api.example.com/data');
echo yield $response->getBody();
```"*