Popularity

5.9

Stable

Activity

0.0

Stable

Stars 81

Watchers 5

Forks 4

Last Commit almost 4 years ago

Monthly Downloads: 30

Programming language: Elixir

License: MIT License

Tags: HTTP

Latest version: v0.0.7

river alternatives and similar packages

Based on the "HTTP" category.
Alternatively, view river alternatives based on common mentions on social networks and blogs.

mint

9.6 7.2 river VS mint

Functional HTTP client for Elixir with support for HTTP/1 and HTTP/2 🌱
gun

9.6 4.2 river VS gun

HTTP/1.1, HTTP/2 and Websocket client for Erlang/OTP.

Close all those tabs. Zigi will handle your updates.

Zigi monitors Jira and GitHub updates, pings you when PRs need approval and lets you take fast actions - all directly from Slack! Plus it reduces cycle time by up to 75%.

Promo www.zigi.ai

Crawler

9.4 0.0 river VS Crawler

A high performance web crawler / scraper in Elixir.
finch

9.4 8.2 river VS finch

Elixir HTTP client, focused on performance
Crawly

9.2 2.1 river VS Crawly

Crawly, a high-level web crawling & scraping framework for Elixir.
scrape

8.5 0.0 river VS scrape

Scrape any website, article or RSS/Atom Feed with ease!
PlugAttack

8.3 0.0 river VS PlugAttack

A plug building toolkit for blocking and throttling abusive requests
neuron

8.2 0.0 river VS neuron

A GraphQL client for Elixir
Ace

8.2 0.0 river VS Ace

HTTP web server and client, supports http1 and http2
webdriver

7.3 0.0 river VS webdriver

WebDriver client for Elixir.
web_socket

6.3 0.0 river VS web_socket

An exploration into a stand-alone library for Plug applications to easily adopt WebSockets.
spell

6.3 0.0 river VS spell

Spell is a Web Application Messaging Protocol (WAMP) client implementation in Elixir. WAMP is an open standard WebSocket subprotocol that provides two application messaging patterns in one unified protocol: Remote Procedure Calls + Publish & Subscribe: http://wamp.ws/
cauldron

5.9 0.0 river VS cauldron

I wonder what kind of Elixir is boiling in there.
http_proxy

5.2 0.0 river VS http_proxy

http proxy with Elixir. wait request with multi port and forward to each URIs
bolt

4.3 0.0 river VS bolt

Simple and fast http proxy living in the Erlang VM
explode

4.3 0.0 river VS explode

An easy utility for responding with standard HTTP/JSON error payloads in Plug- and Phoenix-based applications
sparql_client

4.2 0.0 river VS sparql_client

A SPARQL client for Elixir
Mechanize

4.0 10.0 river VS Mechanize

Build web scrapers and automate interaction with websites in Elixir with ease!
mnemonic_slugs

3.4 0.0 river VS mnemonic_slugs

An Elixir library for generating memorable slugs.
Tube

3.2 0.0 river VS Tube

WebSocket client library written in pure Elixir
uri_template

3.2 0.0 river VS uri_template

RFC 6570 compliant URI template processor for Elixir
etag_plug

3.1 1.4 river VS etag_plug

A simple to use shallow ETag plug
fuzzyurl

3.0 0.0 river VS fuzzyurl

An Elixir library for non-strict parsing, manipulation, and wildcard matching of URLs.
ivar

3.0 0.0 river VS ivar

Ivar is an adapter based HTTP client that provides the ability to build composable HTTP requests.
uri_query

2.6 0.0 river VS uri_query

URI encode nested GET parameters and array values in Elixir
httprot

2.5 0.0 river VS httprot

Prot prot prot.
SpiderMan

2.4 10.0 river VS SpiderMan

SpiderMan,a base-on Broadway fast high-level web crawling & scraping framework for Elixir.
yuri

2.1 0.0 river VS yuri

Elixir module for easier URI manipulation.
lhttpc

1.2 0.0 river VS lhttpc

What used to be here -- this is a backwards-compat user and repo m(
Ralitobu.Plug

1.0 0.0 river VS Ralitobu.Plug

Elixir Plug for Ralitobu, the Rate Limiter with Token Bucket algorithm
plug_wait1

1.0 0.0 river VS plug_wait1

Plug adapter for the wait1 protocol
http_digex

0.9 0.0 river VS http_digex

HTTP Digest Auth Library to create auth header to be used with HTTP Digest Authentication

Do you think we are missing an alternative of river or a related project?

Add another 'HTTP' Package

Popular Comparisons

README

River

NOTE: River is a work in progress and should be considered extremely beta.

River is a general-purpose HTTP client with eventual hopes of full HTTP/2 support (along with support for HTTP/1.1). It is built from the ground up with three major goals:

be fully compliant with RFC 7540
be simple and straightforward to use, in the vein of HTTPoison
be awesome, in the same way that Go's http library (which has built-in, transparent support for HTTP/2) is awesome.

Installation

Add River to your list of dependencies in mix.exs:
```
def deps do
[{:river, "~> 0.0.6"}]
end
```

Ensure River is started before your application:

def application do
[applications: [:river]]
end

Caveats

Currently, River only knows how to make HTTP/2 requests to https:// endpoints. Soon, I'll add the ability to make a request via the Upgrade header so that requests to http:// endpoints will work as well.
River doesn't currently speak HTTP/1.x. Once I finish up basic HTTP/2 support, HTTP1.x is next on the roadmap. The goal when using River in your project is that you should not need to know whether the underlying connection is using HTTP/2 or HTTP/1.x.
River is as beta as it gets, and under active development with no promises of anything being backwards compatible 😬 (until we hit v1.0, of course)

Goals

[x] Basic HTTP/2 support
[ ] HTTP/1 --> HTTP/2 upgrading
[ ] Full HTTP/2 support
[ ] Full HTTP/1.x support

Basic Usage

Simple GET

River.get("https://http2.golang.org/")
=> {:ok,
 %River.Response{__status: :ok,
  body: "<html>\n<body>\n<h1>Go...",
  closed: true, code: 200, content_type: "text/html; charset=utf-8",
  headers: headers: [{":status", "200"},
                     {"content-type", "text/html; charset=utf-8"},
                     {"content-length", "1708"},
                     {"date", "Fri, 30 Sep 2016 04:26:34 GMT"}]}}

Simple PUT

River.put("https://example.com/", "hello world")
=> {:ok, %River.Response{...}}

Request with timeout

# timeout unit is milliseconds
River.get("https://http2.golang.org/", timeout: 10)
=> {:error, :timeout}

river

An HTTP/2 client for Elixir (a work in progress!)