Skip to content
Back to search

openserp

Self-hosted web search for AI agents and SEO. Google, Bing, Yandex, Baidu, DuckDuckGo & Ecosia, rendered in a real browser: ranked results and clean page Markdown. API, CLI, MCP πŸŽ‰

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/karust/openserp with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/karust/openserp'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/karust--openserp/badge.svg)](/listings/karust--openserp)

HTML

<a href="/listings/karust--openserp"><img src="/api/listings/karust--openserp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Docker

Prebuilt images are published to [docker hub: `karust/openserp`](https://hub.docker.com/r/karust/openserp).

# Run the API server via prebuilt image
docker run --rm -p 127.0.0.1:7000:7000 karust/openserp:latest serve -a 0.0.0.0 -p 7000

# Or
docker compose up

Go install

go install github.com/karust/openserp@latest
openserp search duckduckgo "open source serp api" --format markdown

From Source

git clone https://github.com/karust/openserp.git
cd openserp
go build -o openserp .
./openserp serve

First request

# mode=any returns the first engine that responds
curl "http://127.0.0.1:7000/mega/search?engines=bing,google&text=golang+vs+rust&extract=1&mode=any"

<details> <summary>Example JSON response</summary>

{
  "query": {
    "text": "golang vs rust",
    "engines_requested": ["bing", "google"]
  },
  "meta": {
    "request_id": "019ecdc0-a66d-79a4-9d2b-9e9b480d495e",
    "requested_at": "2026-06-16T00:06:55Z",
    "took_ms": 720,
    "engines_responded": ["bing"],
    "engines_failed": [],
    "version": "2.1"
  },
  "results": [
    {
      "id": "s_5a8273f16b19ab64",
      "rank": 1,
      "type": "organic",
      "title": "The Go Programming Language",
      "url": "https://go.dev/",
      "display_url": "go.dev",
      "snippet": "Get Started Playground Tour Stack Overflow Help Packages Standard Library …",
      "domain": "go.dev",
      "favicon": "https://go.dev/favicon.ico",
      "position": {
        "absolute": 1
      },
      "engine": "bing",
      "domain_info": {
        "tld": "dev",
        "sld": "go",
        "category": ""
      },
      "extracted": {
        "title": "Build simple, secure, scalable systems with Go",
        "format": "markdown",
        "content": "## Build simple, secure, scalable systems with Go\n\n![Go Gopher climbing a ladder.](https://go.dev/images/gophers/ladder.svg)\n\n- β€œAt the time, no single team member knew Go, but **within a month, everyone was writing in Go** and we were building out the endpoints. ........",
        "mode_used": "fast",
        "fetched_at": "2026-06-16T00:06:56Z"
      }
    },
    {
      "id": "s_1a364ebcb3035539",
      "rank": 2,
      "type": "organic",
      "title": "Go (programming language) - Wikipedia",
      "url": "https://en.wikipedia.org/wiki/Go_(programming_language)",
      "display_url": "en.wikipedia.org β€Ί wiki β€Ί Go_(programming_language)",
      "snippet": "In Go's package system, each package has a path (e.g., \"compress/bzip2\" or \"golang.org/x/net/html\") and a name (e.g., bzip2 or html). …",
      "domain": "en.wikipedia.org",
      "favicon": "https://en.wikipedia.org/favicon.ico",
      "position": {
        "absolute": 2
      },
      "engine": "bing",
      "domain_info": {
        "tld": "org",
        "sld": "wikipedia",
        "category": ""
      },
      "classification": {
        "content_type": "article",
        "source_hint": "encyclopedia"
      }
    },
    ...
  ],
  "serp_features": [],
  "pagination": {
    "page": 1,
    "has_more": false,
    "next_start": 10
  },
  "clusters": [
    {
      "id": "c_f20b23a020101dce",
      "canonical_url": "https://go.dev/",
      "domain": "go.dev",
      "title": "The Go Programming Language",
      "occurrences": [
        {
          "engine": "bing",
          "rank": 1,
          "result_id": "s_5a8273f16b19ab64"
        }
      ],
      "engines_count": 1,
      "best_rank": 1,
      "score": 0.5
    },
    ...
  ]
}

</details>

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md Β· README Β· 396 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ![OpenSERP](./logo.svg)
  2. # OpenSERP
  3. [![Go Reference](https://pkg.go.dev/badge/github.com/karust/openserp.svg)](https://pkg.go.dev/github.com/karust/openserp)
  4. [![release](https://img.shields.io/github/v/release/karust/openserp)](https://github.com/karust/openserp/releases)
  5. [![Docker Pulls](https://img.shields.io/docker/v/karust/openserp)](https://hub.docker.com/r/karust/openserp)
  6. [![CI](https://github.com/karust/openserp/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/karust/openserp/actions/workflows/ci.yml)
  7. [![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
  8. [![Telegram](https://img.shields.io/badge/Telegram-openserp__cloud-26A5E4?logo=telegram&logoColor=white)](https://t.me/openserp_cloud)
  9. OpenSERP is a **free self-hosted web search for AI agents and SEO.** REST API and CLI for Google, Bing, Yandex, Baidu, DuckDuckGo and Ecosia.
  10. No API keys, no per-search billing. It loads search results in browser and returns structured JSON with source engines and ranks. Read the linked pages as clean Markdown, or connect an agent through MCP.
  11. Works with Claude Code, Cursor, Codex, Claude Desktop and any MCP client, [Open WebUI](https://docs.openwebui.com/features/chat-conversations/web-search/providers/openserp/) (built-in provider), [n8n](https://www.npmjs.com/package/@openserp/n8n-nodes-openserp), and plain HTTP from any language.
  12. [API examples](#search-endpoints) Β· [CLI](#cli-search) Β· [Agent setup](#use-with-ai-agents) Β· [API reference](./docs/openapi.yaml)
  13. ![Claude Code answering a question with OpenSERP over MCP](./docs/agent-demo.gif)
  14. ## Quick Start
  15. ```sh
  16. # Start the API server
  17. docker run --rm --init -p 127.0.0.1:7000:7000 karust/openserp serve -a 0.0.0.0 -p 7000
  18. # Search Google and read the top result as Markdown
  19. curl "http://127.0.0.1:7000/google/search?text=how+do+mcp+servers+work&extract=1"
  20. ```
  21. <details>
  22. <summary>Other ways to install</summary>
  23. ```sh
  24. # Docker Compose
  25. docker compose up
  26. # Go
  27. go install github.com/karust/openserp@latest
  28. openserp serve
  29. # From source
  30. git clone https://github.com/karust/openserp.git
  31. cd openserp && go build -o openserp . && ./openserp serve
  32. ```
  33. Prebuilt binaries for Linux, macOS and Windows are on the [releases page](https://github.com/karust/openserp/releases). Images: [`karust/openserp`](https://hub.docker.com/r/karust/openserp).
  34. PDF extraction calls `mutool`. The Docker image ships it, other installs need MuPDF (`apt install mupdf-tools`).
  35. </details>
  36. ## Use with AI Agents
  37. ### MCP: Claude Code, Codex, Cursor, Claude Desktop
  38. Requires Node.js 18+ and a running OpenSERP server. Add the MCP server to your client:
  39. ```sh
  40. claude mcp add openserp -- npx -y @openserp/mcp
  41. codex mcp add openserp -- npx -y @openserp/mcp
  42. ```
  43. Cursor (`~/.cursor/mcp.json`), Claude Desktop, Windsurf and other clients:
  44. ```json
  45. {
  46. "mcpServers": {
  47. "openserp": { "command": "npx", "args": ["-y", "@openserp/mcp"] }
  48. }
  49. }
  50. ```
  51. On native Windows, use `cmd /c npx -y @openserp/mcp` after `--` in the CLI commands, or `"command": "cmd", "args": ["/c", "npx", "-y", "@openserp/mcp"]` in JSON.
  52. For a remote server, add `"env": { "OPENSERP_BASE_URL": "http://your-host:7000" }` to the `openserp` JSON entry.
  53. Tools: `search`, `mega_search`, `fast_search`, `any_search`, `image_search`, `mega_image`, `extract`, `batch_extract`, `list_engines`. Then just ask: _"Search Google for the latest Postgres release, read the top 2 results and answer with links."_
  54. Optional for Claude Code: copy [skills/openserp-search](./skills/openserp-search) to `~/.claude/skills/` so the agent searches, reads and falls back to another engine the same way every time.
  55. ### Open WebUI
  56. OpenSERP is a built-in web search provider. In **Settings > Admin > Web Search** pick `openserp` and set the URL (`http://host.docker.internal:7000` if Open WebUI runs in Docker). See the [Open WebUI guide](https://docs.openwebui.com/features/chat-conversations/web-search/providers/openserp/).
  57. ### In your own agent
  58. A search tool for any LLM framework is a few lines with the SDK:
  59. ```python
  60. from openserp import OpenSERP
  61. def web_search(query: str) -> list[dict]:
  62. """Search Google and return ranked results for the model."""
  63. with OpenSERP(base_url="http://localhost:7000") as client:
  64. res = client.search(engine="google", text=query, limit=10)
  65. return [
  66. {"rank": r.rank, "title": r.title, "url": r.url, "snippet": r.snippet}
  67. for r in res.results if r.type == "organic"
  68. ]
  69. ```
  70. ```js
  71. import { OpenSERP } from "@openserp/sdk";
  72. const client = new OpenSERP({ baseUrl: "http://localhost:7000" });
  73. const { results } = await client.search({ engine: "google", text: "openserp", limit: 5 });
  74. ```
  75. | Package | Install | Source |
  76. | -------------------------------------------------------------------------------------------- | ------------------------------- | ------------------------------------------------------------------- |
  77. | [`@openserp/mcp`](https://www.npmjs.com/package/@openserp/mcp) - MCP server | `npx -y @openserp/mcp` | [openserpapi/mcp](https://github.com/openserpapi/mcp) |
  78. | [`@openserp/sdk`](https://www.npmjs.com/package/@openserp/sdk) - JS / TS | `npm install @openserp/sdk` | [openserpapi/sdk-js](https://github.com/openserpapi/sdk-js) |
  79. | [`openserp`](https://pypi.org/project/openserp/) - Python | `pip install openserp` | [openserpapi/sdk-python](https://github.com/openserpapi/sdk-python) |
  80. | [`@openserp/n8n-nodes-openserp`](https://www.npmjs.com/package/@openserp/n8n-nodes-openserp) | Install via n8n community nodes | [openserpapi/n8n](https://github.com/openserpapi/n8n) |
  81. More in [examples](./examples): agent tools, RAG context, SEO rank tracking, extraction and image search.
  82. ## Response Example
  83. `GET /google/search?text=how+do+mcp+servers+work&extract=1` (trimmed):
  84. ```json
  85. {
  86. "query": { "text": "how do mcp servers work", "engines_requested": ["google"] },
  87. "meta": { "took_ms": 4353, "engines_failed": [], "version": "2.1" },
  88. "results": [
  89. {
  90. "rank": 1,
  91. "type": "organic",
  92. "engine": "google",
  93. "title": "What Is the Model Context Protocol (MCP) and How It Works",
  94. "url": "https://www.descope.com/learn/post/mcp",
  95. "domain": "descope.com",
  96. "snippet": "MCP is an open standard that lets AI applications connect to external tools, data, and services through a client-server protocol built on JSON-…",
  97. "position": { "absolute": 1 },
  98. "extracted": {
  99. "format": "markdown",
  100. "content": "The Model Context Protocol (MCP) is an open standard that defines how AI applications connect to external tools, data sources, and services. MCP clients inside AI apps send requests to MCP servers, ..."
  101. }
  102. },
  103. {
  104. "rank": 2,
  105. "type": "organic",
  106. "engine": "google",
  107. "title": "No Dumb Questions: What is an MCP server and why do I ...",
  108. "url": "https://stackoverflow.blog/2026/05/08/no-dumb-questions-mcp",
  109. "domain": "stackoverflow.blog"
  110. }
  111. ]
  112. }
  113. ```
  114. Results keep their source engine and rank. Ads are typed separately from organic results; `extract=N` attaches up to N organic pages as Markdown and records per-page failures in `extracted.error`. Full schema in the [OpenAPI spec](./docs/openapi.yaml).
  115. ## Why OpenSERP
  116. - **Browser-backed search.** Chromium loads the rendered SERP, including supported answer boxes, related searches and AI summaries. Raw HTTP mode is also available for Google, Yandex, Baidu and Ecosia.
  117. - **Six engines, one schema.** Google, Bing, Yandex, Baidu, DuckDuckGo and Ecosia return the same JSON. Engine and rank survive a multi-engine merge, so you can see who ranked what.
  118. - **Search and read in one call.** `extract=N` adds page Markdown under the top organic results, `/extract/batch` reads up to 20 URLs, and a dead link comes back as an error item instead of failing the batch.
  119. - **Yours to run.** One Go binary or Docker image, with HTTP/SOCKS5 proxies, cache, retries, rate limits and circuit breakers. No per-query fees; you cover compute and proxies.
  120. ## Compared to Paid Search APIs
  121. | Feature | OpenSERP | [Cloud](https://openserp.org/cloud/) | [Tavily](https://www.tavily.com/pricing) | [SerpApi](https://serpapi.com/pricing) | [Exa](https://exa.ai/pricing) |
  122. | ---------------------------------- | --------------------- | ------------------------------------ | ---------------------------------------- | -------------------------------------- | ----------------------------- |
  123. | Google results | βœ… | βœ… | 🟨 Undisclosed | βœ… | ❌ |
  124. | Search engines | 6 | 6 | Own retrieval | Many | Exa index |
  125. | Original engine ranks | βœ… | βœ… | ❌ | βœ… | ❌ |
  126. | Page extraction | βœ… Markdown, batch | βœ… Markdown, batch | βœ… | βœ… | βœ… |
  127. | Self-hosting | βœ… | ❌ | ❌ | ❌ | ❌ |
  128. | SEO monitoring, rank tracking | 🟨 | βœ… | ❌ | 🟨 | ❌ |
  129. | PR monitoring, competitor tracking | 🟨 | βœ… Beta | 🟨 | 🟨 | βœ… API |
  130. | AI reports and alerts | 🟨 | βœ… | 🟨 | 🟨 | 🟨 |
  131. | Pricing | Free + infrastructure | PAYG, **$0.0078/credit** | $30/mo, 4k basic credits | $25/mo, 1k searches | PAYG, $4/1k Lite searches |
  132. βœ… Available Β· 🟨 Partial, unconfirmed or requires integration Β· ❌ Unavailable
  133. ## Search Endpoints
  134. Engine names: `google`, `yandex`, `baidu`, `bing`, `duckduckgo` (also `duck`; `ddg` works in `engines=` and the CLI), `ecosia`.
  135. Use a dedicated endpoint when the source engine matters, `any` for ordered fallback, or `balanced` to compare engines. Search supports JSON, Markdown, text and NDJSON, plus language, region, date, site and file filters.
  136. Dedicated engine endpoints:
  137. ```bash
  138. curl "http://127.0.0.1:7000/google/search?text=golang&limit=10"
  139. ```
  140. Image search:
  141. ```bash
  142. curl "http://127.0.0.1:7000/bing/image?text=golang+logo&limit=10"
  143. ```
  144. Megasearch:
  145. ```bash
  146. curl "http://127.0.0.1:7000/mega/search?text=golang&limit=10"
  147. ```
  148. `/mega/search` returns the same envelope as engine endpoints plus `clusters`: results are deduplicated by normalized URL, and clusters keep the per-engine occurrences and ranks.
  149. | Mode | Best for | Behavior |
  150. | ---------- | -------------------------------------- | ----------------------------------------------------------------- |
  151. | `balanced` | Most multi-engine SERP workflows | Queries engines in parallel and merges results |
  152. | `fast` | One engine selected by latency history | Uses one engine; does not fall back on failure |
  153. | `any` | Ordered fallback | Tries engines in order until one succeeds, even with zero results |
  154. <details>
  155. <summary>More megasearch examples</summary>
  156. ```bash
  157. # Fast mode
  158. curl "http://127.0.0.1:7000/mega/search?text=golang&mode=fast&engines=google,bing,yandex"
  159. # Any mode
  160. curl "http://127.0.0.1:7000/mega/search?text=golang&mode=any&engines=google,yandex,bing"
  161. # Balanced mode with aggregation controls
  162. curl "http://127.0.0.1:7000/mega/search?text=golang&mode=balanced&dedupe=true&merge=true"
  163. # Advanced filtering
  164. curl "http://127.0.0.1:7000/mega/search?text=golang&engines=google,bing&limit=20&date=20250101..20251231&lang=EN&region=US"
  165. # Image megasearch
  166. curl "http://127.0.0.1:7000/mega/image?text=golang+logo&limit=20"
  167. ```
  168. </details>
  169. List engines:
  170. ```bash
  171. curl "http://127.0.0.1:7000/mega/engines"
  172. ```
  173. URL extraction:
  174. ```bash
  175. # Extract one URL as JSON
  176. curl "http://127.0.0.1:7000/extract?url=https://example.com&mode=auto"
  177. # Return clean page markdown
  178. curl "http://127.0.0.1:7000/extract?url=https://example.com&format=markdown"
  179. # Keep headings, signatures and code blocks on documentation pages
  180. curl "http://127.0.0.1:7000/extract?url=https://docs.python.org/3/library/copy.html&format=markdown&preserve_structure=true"
  181. # PDFs return their text layer (scans without one return an error)
  182. curl "http://127.0.0.1:7000/extract?url=https://bitcoin.org/bitcoin.pdf&format=markdown"
  183. # Extract several URLs at once - returns a bare [{page_content, metadata}] array
  184. # (Open WebUI external loader compatible); failed URLs become items with metadata.error
  185. curl -X POST "http://127.0.0.1:7000/extract/batch" \
  186. -H "Content-Type: application/json" \
  187. -d '{"urls":["https://example.com","https://go.dev"],"mode":"fast"}'
  188. # Embed extracted content under the top organic results
  189. curl "http://127.0.0.1:7000/google/search?text=llm+observability&extract=2&format=markdown"
  190. ```
  191. ## CLI Search
  192. No server required - query an engine straight from the terminal. The CLI shares the same engines, formats, and filters as the API.
  193. ```sh
  194. openserp search ecosia "weather in london" --format markdown
  195. ```
  196. ![OpenSERP CLI demo](./docs/demo.gif)
  197. <details>
  198. <summary>CLI output and more examples</summary>
  199. ```markdown
  200. # Search results for "weather in london"
  201. **Query:** weather in london - **Engines:** ecosia - **Took:** 866ms
  202. ## Results
  203. ### 1. London - BBC Weather
  204. **bbc.com β€Ί weather β€Ί 2643743** - organic
  205. Latest forecast for London ... Tonight will continue dry, and there will be mainly clear skies. Just a few patches of cloud drifting in from the north at times.
  206. -> https://www.bbc.com/weather/2643743
  207. ### 2. London (Greater London) weather - Met Office
  208. **weather.metoffice.gov.uk β€Ί forecast β€Ί gcpvj0v07** - organic
  209. Remaining warm with light winds and dry. Possibly cloudy at times Monday and Tuesday, then Wednesday sunnier conditions are likely.
  210. -> https://weather.metoffice.gov.uk/forecast/gcpvj0v07
  211. ```
  212. More CLI examples:
  213. ```sh
  214. # JSON is the default format
  215. openserp search google "golang generics" --limit 20
  216. # Plain text, German results
  217. openserp search yandex "wetter berlin" --format text --lang DE --region DE
  218. # Restrict to a site and stream NdJSON
  219. openserp search bing "release notes" --site github.com --format ndjson
  220. # Embed clean page content from the top 2 organic results
  221. openserp search google "llm observability" --extract 2 --format markdown
  222. # Browserless (raw HTTP) mode through a proxy
  223. # (raw mode: google, yandex, baidu, ecosia)
  224. openserp search ecosia "weather in london" --raw --proxy http://user:pass@127.0.0.1:8080
  225. ```
  226. </details>
  227. Run `openserp search --help` for the full flag list. Results go to stdout, logs to stderr. Set verbosity with `--log_level error|warn|info|debug|trace` or `OPENSERP_APP_LOG_LEVEL` (CLI default: `warn`). `serve` also writes `./logs.txt` unless `app.save_log: false`.
  228. ## Query Parameters
  229. <details>
  230. <summary>Common parameters</summary>
  231. | Parameter | Description | Example |
  232. | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
  233. | `text` | Search query | `golang programming` |
  234. | `lang` | Language code | `EN`, `DE`, `RU`, `ES` |
  235. | `region` | Market/location hint. Countries/locales work across engines; Google also accepts city names via `uule`; Yandex accepts numeric `lr`. | `DE`, `en-GB`, `Berlin`, `213` |
  236. | `date` | Date range | `20250101..20251231` |
  237. | `file` | File extension | `pdf`, `doc`, `xls` |
  238. | `site` | Site-specific search | `github.com` |
  239. | `limit` | Number of organic results, max 100. When omitted or `<=10`, only the first SERP page is parsed. | `25`, `50` |
  240. | `start` | Pagination offset | `0`, `10`, `20` |
  241. | `format` | Output format | `json`, `markdown`, `text`, `ndjson` |
  242. | `extract` | Fetch and embed target-page content for organic results. Ads and answer rows are skipped. `0`/`false` off, `true`/`1` top organic result, `N` up to N (1-5). `extract_mode`/`min_runes` imply `extract=true` unless `extract=0` | `1`, `3`, `true` |
  243. | `extract_mode` | Extraction strategy: raw HTTP first, raw only, or browser-rendered | `auto`, `fast`, `rendered` |
  244. </details>
  245. <details>
  246. <summary>Engine-specific parameters</summary>
  247. | Parameter | Supported engines | Notes |
  248. | -------------- | ----------------- | -------------------------------------------------------------------------------------------------------------------------------- |
  249. | `filter` | `google` | Duplicate filter: `true` hides similar results, `false` includes them. |
  250. | `features` | browser `Search` | Populate `serp_features[]` from the live page. Defaults to `true`. |
  251. | `resolve_urls` | `google` | Turn Google `/goto` redirect links into destination URLs without fetching destination pages (ads skipped). `true` (default), `false`, or top `N`. |
  252. </details>
  253. Bing localizes by exit IP. `lang` sets its interface language; `region` sends a country hint except for `US`, `CN` and `RU`, which caused unrelated results in testing. For those locations, use a proxy in the target country.
  254. ## Proxy Support
  255. OpenSERP supports HTTP and SOCKS5 proxies.
  256. ```bash
  257. ./openserp serve --proxy socks5://127.0.0.1:1080
  258. ./openserp search bing "query" --proxy http://user:pass@127.0.0.1:8080
  259. ```
  260. Engines can return CAPTCHAs, rate limits or unrelated results. Browser mode does not eliminate these; try another engine or a proxy when needed.
  261. Advanced proxy configuration is available in [config.yaml](./config.yaml). You can enable tagged proxy pools and per-request override via `X-Use-Proxy: <tag>` or `X-Use-Proxy: direct`.
  262. ## API Docs
  263. Once the server is running, the interactive docs are available locally:
  264. - Swagger UI: `http://127.0.0.1:7000/docs` - full schemas, error shapes, and the `/health`, `/ready`, `/stats/*` endpoints
  265. - OpenAPI YAML: `http://127.0.0.1:7000/openapi.yaml`
  266. To browse the spec without running the server, see [docs/openapi.yaml](./docs/openapi.yaml). For how OpenSERP works internally, see the [architecture docs](https://openserp.org/docs/architecture/).
  267. ## Contributing
  268. Contributions are welcome. See [docs/CONTRIBUTING.md](./docs/CONTRIBUTING.md).
  269. ## License
  270. MIT. See [LICENSE](LICENSE).
  271. ## Feedback & Updates
  272. - [GitHub Issues](https://github.com/karust/openserp/issues) - bugs, feature ideas, and reproducible issues.
  273. - [feedback@openserp.org](mailto:feedback@openserp.org) - private notes, longer feedback, or anything that does not fit GitHub Issues.
  274. - [Telegram](https://t.me/openserp_cloud) - OpenSERP news, release notes, and project updates.
  275. > OpenSERP is free and open-source. Only links listed in this repository and on [openserp.org](https://openserp.org) are associated with the project.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.