Six languages, one API

SDKs for every stack you build with.

Typed clients for the Repull API in TypeScript, Python, PHP, Go, Ruby, and .NET. Install in seconds, get autocomplete for every endpoint, and ship integrations faster than you would against raw HTTP.

Licensing

TypeScript SDK is published under the Repull SDK Community License — free for production use up to 100 listings under management. A commercial license is required above that threshold.

Python, PHP, Go, Ruby, and .NET SDKs are published under MIT — these are thin generated bindings around the same Repull API.

Your usage of the underlying Repull API is governed by your account plan, regardless of which SDK you use.

Featured · Open source

Channel Manager Template

A production-ready, forkable channel-manager built on @repull/sdk. Calendar UI, reservations, listings, connections, messaging, reviews — yours to ship in a weekend.

Open live demo

repull-channel-manager

Template
@repull/channel-managerv0.1.0-alphaRepull Community License

Next.js 16 starter with calendar, reservations, listings, connections, messaging, and reviews. Powered by Repull · AI features powered by Vanio AI. Fork it, deploy your own, or use as a reference architecture.

$git clone https://github.com/ivannikolovbg/repull-channel-manager

Why use an SDK over raw HTTP?

The Repull REST API is fully documented and you can hit it with fetch, requests, or curltomorrow. You probably shouldn't. Here's what an SDK gives you that you'd otherwise have to write yourself.

Typed responses

Every endpoint returns a typed object. Auto-complete reservations, properties, guests in your editor — no manual interfaces.

Auth that just works

API key handled at construction. No header hand-rolling, no Bearer-token typos at 2am.

Pagination iterators

Iterate over results. The SDK fetches the next page transparently — you never count cursors.

OAuth flow helpers

Connect-widget redirect URLs, state validation, callback parsing. Skip the OAuth ceremony.

Error normalization

Every PMS fails differently. The SDK wraps them in a consistent error shape with code, status, and PMS payload.

Smart retries

Idempotency keys generated for mutating calls. Network blips and 429s retry with jitter, automatically.

Shipping today

All open source on GitHub

TypeScript

Flagship
@repull/sdkLive on npm · v0.2.0Repull Community

The hand-crafted TypeScript REST client. Typed responses for every endpoint, automatic pagination, idempotent retries, and OAuth helpers. Works in Node, Bun, Deno, and edge runtimes.

$npm install @repull/sdk
typescript
import { Repull } from '@repull/sdk'

const repull = new Repull({
  apiKey: process.env.REPULL_API_KEY!,
})

const reservations = await repull.reservations.list({ limit: 10 })
console.log(reservations.data[0].guest.name)

Python

Async Python client generated from the Repull OpenAPI spec via openapi-python-client. Typed response models, async/await first, httpx transport. Distribution name on PyPI is repull-sdk; the Python module / import path is still repull.

$pip install repull-sdk
python
import asyncio, os
from repull import AuthenticatedClient
from repull.api.reservations import get_v1_reservations

async def main():
    client = AuthenticatedClient(
        base_url="https://api.repull.dev",
        token=os.environ["REPULL_API_KEY"],
    )
    async with client as c:
        page = await get_v1_reservations.asyncio(client=c, limit=10)
    for r in page.data or []:
        print(r.id, r.check_in, r.platform)

asyncio.run(main())

PHP 8.1+ client generated from the Repull OpenAPI spec — Guzzle by default, swap in any PSR-18 client. Available on Packagist.

$composer require repull/sdk
php
<?php
require 'vendor/autoload.php';

use GuzzleHttp\Client;
use Repull\Api\ReservationsApi;
use Repull\Configuration;

$config = Configuration::getDefaultConfiguration()
    ->setAccessToken(getenv('REPULL_API_KEY'));
$api = new ReservationsApi(new Client(), $config);

foreach ($api->v1ReservationsGet(limit: 10)->getData() as $r) {
    echo $r->getId() . ' ' . $r->getPlatform() . PHP_EOL;
}

Go

github.com/ivannikolovbg/repull-goLive on pkg.go.dev · v0.2.0MIT

Idiomatic Go client generated via oapi-codegen. Typed structs, context-aware methods, bring-your-own http.Client.

$go get github.com/ivannikolovbg/repull-go
go
package main

import (
    "context"
    "fmt"
    "os"

    "github.com/ivannikolovbg/repull-go/repull"
)

func main() {
    c, _ := repull.NewClientWithResponses(
        repull.DefaultBaseURL,
        repull.WithBearer(os.Getenv("REPULL_API_KEY")),
    )
    limit := 10
    resp, _ := c.GetV1ReservationsWithResponse(context.Background(),
        &repull.GetV1ReservationsParams{Limit: &limit})
    fmt.Printf("%s\n", resp.Body)
}

Ruby gem generated via openapi-generator. Faraday transport, typed response objects, drop-in for any Rails or Sinatra app.

$gem install repull
ruby
require 'repull'

config = Repull::Configuration.new
config.access_token = ENV.fetch('REPULL_API_KEY')
config.host = 'api.repull.dev'

client = Repull::ApiClient.new(config)
result = Repull::ReservationsApi.new(client).v1_reservations_get(limit: 10)

result.data.each do |r|
  puts "#{r.id} #{r.check_in} #{r.platform}"
end

.NET

Repull.SDKComing soonMIT

Cross-platform .NET 8 client generated via Microsoft Kiota — async APIs, dependency-injection ready, nullable-reference-type aware. Coming soon to NuGet.

Available soon. Drop your email at hello@repull.dev to get notified the moment this SDK is published.

All five generated SDKs share a single source of truth — the OpenAPI spec at api.repull.dev/openapi.json. Each repo has a scripts/regen.sh that pulls the latest spec and regenerates the bindings, so a new endpoint lights up in every language at once.

AI integrations

Built on top of the TypeScript SDK. Plug Repull into Claude Desktop, Cursor, or any Vercel AI SDK agent. All MIT.

@repull/ai-sdk

AI
@repull/ai-sdkLive on npm · v0.1.0MIT

Vercel AI SDK tool bindings. Drop Repull into any streamText / generateText call and your model can list reservations, send messages, and update pricing through native tool calls.

$npm install @repull/ai-sdk ai @ai-sdk/openai
typescript
import { streamText } from 'ai'
import { openai } from '@ai-sdk/openai'
import { repullTools, RepullClient } from '@repull/ai-sdk'

const tools = repullTools(
  new RepullClient({ apiKey: process.env.REPULL_API_KEY! })
)

const result = await streamText({
  model: openai('gpt-4o'),
  tools,
  prompt: 'List my reservations for next week',
})

@repull/mcp

MCP
@repull/mcpLive on npm · v0.2.0MIT

Model Context Protocol server. Plug Repull into Claude Desktop, Cursor, Windsurf, Zed, or any MCP-compatible client. Your AI assistant calls reservations, properties, and messaging tools natively — no glue code.

$npx -y @repull/mcp
json
{
  "mcpServers": {
    "repull": {
      "command": "npx",
      "args": ["-y", "@repull/mcp"],
      "env": { "REPULL_API_KEY": "sk_..." }
    }
  }
}

Repull Chat Demo

Demo
repull-chat-demovMIT

A working chat app built on @repull/ai-sdk. Ask it for reservations, properties, or guest messages — it dispatches real Repull tool calls and streams answers back. Fork it as your starter.

$git clone github.com/ivannikolovbg/repull-chat-demo
bash
git clone https://github.com/ivannikolovbg/repull-chat-demo
cd repull-chat-demo
npm install
echo "REPULL_API_KEY=sk_test_..." > .env.local
echo "OPENAI_API_KEY=sk-..." >> .env.local
npm run dev

@repull/mcp is being submitted to awesome-mcp-servers. Star it and the community-curated index will surface Repull to thousands of AI builders.

Building something with Repull?

Tell us at hello@repull.dev — we'll feature your project in the showcase, send swag, and prioritize the SDKs you need most.

Get in touch
AI