# Kobe Food Business Permit Feed (`jp-public-data/kobe-food-permits-query`) Actor

Monthly Kobe permit data checked daily at 06:15 JST. Queries are free and return no stored data when the last successful official-source check is over 30 hours old.

- **URL**: https://apify.com/jp-public-data/kobe-food-permits-query.md
- **Developed by:** [株式会社MaSANO Vida](https://apify.com/jp-public-data) (community)
- **Categories:** Business, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.03 / verified query with results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Kobe Food Business Permit Feed

Verified, machine-readable food business permit records from official City of Kobe open data. This Actor is for AI agents and data workflows that need permit decision dates, validity dates, public facility names, business categories, and locations with source and license metadata.

神戸市が公開する「生活衛生関係許可施設等の情報提供」をもとに、飲食店営業の許可情報を構造化する商品です。対象地域は神戸市であり、日本全国の飲食店データではありません。また、これは行政上の営業許可情報であり、開店・閉店情報ではありません。

### What the output means / データの意味

Each result is a verified `permit_granted` administrative event. Important fields include:

- `permit_number`, `permit_date`, and `valid_until`;
- `facility_name_ja`, `business_category_ja`, and the source’s `application_type_ja`;
- public region codes and facility address;
- `does_not_assert`, always documenting that the record does not assert `business_opened` or `business_closed`;
- source URL, source period, retrieval time, last verification time, license, and attribution.

神戸市は、法改正後の手続では既存営業の継続であっても申請区分が「新規」になる場合があると説明しています。そのため、`application_type_ja: "新規"` を「新規開店」と読み替えません。月次ファイルから消えた施設も「閉店」と判定しません。

### Baseline, privacy, and freshness / 基準データ・個人情報・鮮度

The initial validated file contained 393 rows, of which 319 were restaurant-business permit records. All 319 were stored only as the initial comparison baseline. The initial run emitted **zero new events**, so those records cannot be sold or described as new openings. Only a record added or changed after the baseline can enter the customer manifest.

The source columns for operator name and phone number are intentionally excluded. Output includes `removed_private_fields` to make this transformation explicit. No opening, closure, or business-status inference is performed.

The City of Kobe source is normally published monthly, while a separate private updater checks daily at **06:15 JST** for a changed official file. A successful check updates the verification timestamp even when the file is unchanged and creates zero new events. Public queries read a verified snapshot bundled into the Actor build and never read publisher-owned Apify storage. Before charging, every query checks the last successful official-source check. If it is more than **30 hours old**, the Actor returns `source_unavailable`, `charged: false`, an empty `items` array, and explicit freshness metadata instead of selling old data. Failed or skipped updater runs—including runs not started because account credit is unavailable—cannot advance this timestamp.

### Input example

```json
{
  "dateFrom": "2026-09-01",
  "dateTo": "2026-09-30",
  "eventTypes": ["permit_granted"],
  "region": ["JP-28-Kobe"],
  "query": "中央区",
  "limit": 10
}
```

The run dataset contains one response envelope with `status`, `last_successful_check_at`, `data_period`, `freshness` (state, age, 30-hour maximum, and sale permission), `data_fresh_as_of`, `snapshot` (version, creation time, item count, byte size, and SHA-256 integrity), `items`, `sources_checked`, and `warnings`. A representative output is included in `samples/food-permit-query-output.json` in the source package.

### AI and API use

Run the Actor in Apify Console, through the Actor REST API, official API clients, or Apify MCP integrations. An agent passes JSON input and reads the default dataset URL exposed by the output schema. The Actor uses limited permissions and does not use Standby mode.

AI agents can pay through an Apify account, an Apify AGI prepaid token purchased over x402 or MPP, or—after Apify confirms eligibility—Skyfire per-request payment. Agentic payment protocols are operated by Apify and may change. A buyer should always set a maximum charge for each run.

### Pricing / 料金

- Primary event: `verified-query`
- Price: **US$0.03 once per successful run that returns at least one verified item**
- Maximum items: 20 per query
- Platform usage: included in the event price
- Free responses: `no_matches`, `degraded`, `source_unavailable`, failed runs, and owner update runs
- No synthetic start or dataset-item charge is used, so a zero-result response does not trigger a product charge.

Publication is blocked until the publisher deletes both `apify-actor-start` and `apify-default-dataset-item` in Apify Console, saves and reopens the settings, and verifies that `verified-query` is the only chargeable event. Automatic synthetic charges cannot be prevented or reversed by Actor code. Removing the start event also means the publisher bears the first five seconds of compute.

At US$0.03, one query is approximately ¥4.50 at an illustrative ¥150/US$. Exchange rates and any buyer-side wallet/network costs are outside the Actor price. The dataset field `charged` states whether this run triggered the custom event.

### Source, rights, and attribution / 出典・利用条件

- Official source: [神戸市 生活衛生関係許可施設等の情報提供](https://www.city.kobe.lg.jp/a99427/kenko/health/hygiene/dataset.html)
- Open-data policy: [神戸市オープンデータ利用規約](https://data.city.kobe.lg.jp/policy/)
- License: Creative Commons Attribution 2.1 Japan (CC BY 2.1 JP)
- Required attribution included in every event: `出典：神戸市「生活衛生関係許可施設等の情報提供」（本サービスが加工）`

Commercial reuse is permitted under the stated license with attribution. This product is processed by the publisher and is not guaranteed or endorsed by the City of Kobe. Users must consult the official source for authoritative information.

The output is provided as processed informational data, without warranties of completeness, timeliness, merchantability, fitness for a particular purpose, or business status. It must not be used to assert that a facility opened, closed, or is currently operating. Users remain responsible for checking the official source before making regulatory, commercial, or financial decisions.

Publisher / 販売者: **株式会社MaSANO Vida (MaSANO Vida Co., Ltd.)**

Support questions should include the Actor run ID and event ID, but must not include confidential or personal data.

# Actor input Schema

## `dateFrom` (type: `string`):

Inclusive ISO date (YYYY-MM-DD).

## `dateTo` (type: `string`):

Inclusive ISO date (YYYY-MM-DD).

## `eventTypes` (type: `array`):

Optional event types. Currently permit_granted.

## `region` (type: `array`):

Optional region filters. Kobe permit records use JP-28-Kobe.

## `query` (type: `string`):

Keyword matched against verified public fields.

## `limit` (type: `integer`):

Maximum number of verified events returned.

## Actor input object example

```json
{
  "dateFrom": "2026-09-01",
  "dateTo": "2026-09-30",
  "eventTypes": [
    "permit_granted"
  ],
  "region": [
    "JP-28-Kobe"
  ],
  "query": "中央区",
  "limit": 20
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("jp-public-data/kobe-food-permits-query").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("jp-public-data/kobe-food-permits-query").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call jp-public-data/kobe-food-permits-query --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jp-public-data/kobe-food-permits-query"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/co1QoQRwATZejfDGY/builds/kpayouDIOjNmDvbIz/openapi.json