# Sharetribe MCP > Sharetribe MCP Server gives your AI agent full administrative control over a custom marketplace. You can manage listings, audit user profiles, and force payment transitions using natural language prompts. It lets your client perform operations—like approving entries or marking transactions as complete—without navigating complex vendor panels. ## Overview - **Category:** ecommerce - **Price:** Free - **Tags:** marketplace-management, transaction-routing, user-moderation, peer-to-peer, listing-management, community-governance ## Description This server gives your AI agent full admin control over a custom marketplace, letting you manage listings, audit user profiles, and force payment transitions using nothing but natural language prompts. You don't have to navigate complex vendor panels; your agent just talks to the system and gets it done. **Moderate Listings:** To get an overview of every piece of inventory, your agent runs `list_listings`, which generates a full directory of all marketplace entries, often filtered by status or category. If you need the granular details for one specific item—say, checking dimensions or vendor notes—you pull those exact specifics using `get_listing` with its unique ID. Once you've vetted an entry and it’s ready to go live, your agent approves it instantly with `approve_listing`, making it publicly visible on the marketplace. **Track Market Activity:** To keep tabs on what’s actually happening financially across the platform, your client uses `list_transactions` for a broad overview of all historical and current financial movements. If you need deep visibility into one particular payment or booking—maybe checking why a deposit stalled—you call `get_transaction`, which retrieves every detail and the exact status of that single record. When an order is ready to move from 'pending' to 'complete,' your agent forces operational momentum using `transition_transaction`. This action moves an existing transaction to a new state, closing out the lifecycle. **Audit User Profiles:** You gotta keep tabs on who’s doing what. To see every person registered in the system, your agent runs `list_users`, giving you a complete directory for audits. If you want to check someone's account history or profile details—maybe verify their address or membership status—your agent calls `get_user` with that individual's specific data. For behavioral tracking and moderation, it pulls a full collection of reviews using `list_reviews`, letting you audit everything from glowing feedback to problematic content. **The Full Scope:** Your AI client handles three core areas: the goods (listings), the people (users), and the money (transactions). You get administrative power over listing visibility by running `list_listings` and then approving items with `approve_listing`. If you need to verify a transaction’s status, it'll pull all records via `list_transactions`, check specific details using `get_transaction`, or force the state change with `transition_transaction`. Similarly, when auditing people, your agent lists every account using `list_users` and gets deep profile info for any single user. You can also keep an eye on the whole marketplace activity by calling `list_reviews` to check all moderation queues. ## Tools ### approve_listing Marks a pending listing as approved, making it publicly visible on the marketplace. ### get_listing Pulls all specific details for one single marketplace entry using its unique ID. ### get_transaction Retrieves deep details and current status for a specific payment or booking transaction. ### get_user Gets the full profile and account data for a single registered user. ### list_listings Generates an enumerated list of all marketplace listings, often filtered by status or category. ### list_reviews Pulls a collection of reviews left on the platform for moderation and auditing. ### list_transactions Provides an overview list of all historical and current marketplace financial transactions. ### list_users Lists every user account registered on the platform, providing a directory for audits. ### transition_transaction Forces an existing transaction to move from its current state (like 'pending') to a new operational state (like 'complete'). ## Prompt Examples **Prompt:** ``` Retrieve all listings that are currently stuck in the 'pendingApproval' state. ``` **Response:** ``` Initiating a tactical sweep utilizing `list_listings` aggressively filtered strictly down to the `pendingApproval` state index revealed 4 latent entries idling without resolution. These include "Vintage Bicycle Framework" and three subsequent ambiguous property rental offerings. ``` **Prompt:** ``` Retrieve the details and lifecycle state of the specific transaction bound to the order ID 9c42c2-8491-a9f. ``` **Response:** ``` Drilling precisely using the `get_transaction` node on string identifier '9c42c2-8491-a9f' unearthed an active, persistent booking element. The current underlying lifecycle state displays officially locked as `transition/preauthorized`. ``` ## Capabilities ### Moderate Listings The agent lists all marketplace entries, retrieves specific listing details, and approves pending items for public visibility. ### Control Transaction State You can read the status of any transaction and advance its lifecycle—moving an order from 'pending' to 'confirmed' or 'complete'. ### Audit User Profiles The agent fetches user profiles and lists all registered users, allowing you to check account details or track behavior. ### Monitor Reviews You can pull a complete list of marketplace reviews for moderation, checking both positive feedback and problematic content. ### Track Market Activity The client lists all transactions and listings in the system, giving you an overview of what's happening across the platform. ## Use Cases ### A listing got stuck in 'pendingApproval'. An admin finds a handful of new listings that never get approved. Instead of manually filtering by status, they tell their agent to run `list_listings` and filter strictly for the 'pendingApproval' state index. The agent pulls the IDs, then uses `get_listing` on each ID to review it before running `approve_listing`. Problem solved in minutes. ### A customer reported a payment failure. The support team gets notified about an order stuck at 'preauthorized.' They tell their agent to run `get_transaction` using the order ID. The agent confirms the status and, if necessary, runs `transition_transaction` to move it past the payment hurdle. This fixes the issue without touching a dashboard. ### A user is repeatedly posting bad content. The moderator needs to review the account history for a banned user. They start by running `list_users` to find the ID, then use `get_user` to see the full profile details and behavior patterns. Finally, they run `list_reviews` to pull all associated negative feedback. ### Running an end-of-day financial reconciliation. The finance team needs a snapshot of all completed sales. They instruct their agent to run `list_transactions`, filtering for 'complete' status, giving them the total count and IDs needed to generate reports. This is much faster than running reports in a separate accounting tool. ## Benefits - Speed up content moderation. Instead of clicking through pages to find items needing review, you ask your agent to run `list_listings` and then uses `approve_listing` on the results instantly. No UI friction. - Solve payment bottlenecks. When a transaction stalls in limbo, don't wait for manual intervention. You can audit it with `get_transaction` and force progress using `transition_transaction`—you get immediate state change confirmation. - Maintain data integrity. By running `list_users`, you can pull account lists to check compliance or identify inactive accounts before they become a problem. It's full visibility, zero clicks. - Automate audit logging. You don't need multiple tabs open for user checks. Running `get_user` gives you the specific profile data needed—whether it's for a suspicious account or just verifying details. - Centralize oversight. Instead of checking transaction logs in one place and reviews in another, your agent uses `list_transactions` and `list_reviews` to pull all operational concerns into one chat thread. ## How It Works The bottom line is: You talk to your agent like it's an admin user on the platform's backend, and it executes the necessary function calls automatically. 1. Tell your AI agent which data set to look at (e.g., 'list all pending listings'). 2. The server returns a list or record ID, and you specify the target item. 3. Your agent runs the appropriate tool (like `approve_listing`) using the provided IDs to execute the desired action. ## Frequently Asked Questions **How do I find all listings that are waiting for review using list_listings?** You can run `list_listings` and filter by the specific status ID, like 'pendingApproval.' This function returns a collection of IDs for every item in that state. You then use `get_listing` on those IDs to see the content. **Can I force an order from pending to complete using transition_transaction?** Yes, that's what `transition_transaction` does. You must first provide the specific transaction ID and then tell the agent the target state (e.g., 'complete'). The tool moves it and confirms the change. **What is the difference between get_listing and list_listings?** `list_listings` gives you a directory—a collection of IDs or summaries for many listings. `get_listing`, however, takes one specific ID and returns all the deep details on just that single entry. **How do I check if a user is authorized to approve something?** You should run `list_users` first to get an overview. If you need deeper context on their behavior, use `get_user`. This helps verify the account's status before running tools like `approve_listing`. **If I run `get_listing` with an invalid ID, what error does my agent receive?** It returns a specific HTTP 404 status code and an empty data payload. Your AI client must check for this explicit failure state to prevent the workflow from halting unexpectedly. **Does running `list_users` repeatedly cause rate limiting issues?** Yes, continuous calls to list functions consume your API quota rapidly. We suggest batching requests or adding a small delay loop between multiple data pulls for stable performance. **When I use `list_transactions`, what core metrics are guaranteed in the output?** The result set always includes the transaction UUID, its current status code, and the associated user ID. This reliable structure lets your agent immediately verify order ownership and lifecycle stage. **How do I filter `list_reviews` to only see reviews for a specific listing?** You must pass the target listing's unique ID as a mandatory parameter in the call. This limits the scope, ensuring your agent analyzes only the reviews tied directly to that piece of inventory. **Can the AI forcefully complete an active marketplace payment transition?** Absolutely. Through the `transition_transaction` method, your prompt can dictate the order pipeline. Ensure you pass the specific UUID of the order and the explicit, configured transition name (e.g., "transition/accept" or "transition/complete") to force the lifecycle into its subsequent operational phase immediately. **Why use the Integration API instead of the Marketplace API?** Because the `Integration API` is the unadulterated administrator backend designed for secure backend logic rather than client interfaces. This permits system-level moderation, transaction configuration, and override state. **Can this integration modify review ratings directly?** Currently, the integration specifically implements `list_reviews` as a query mechanism tailored exclusively around monitoring and auditing capabilities. It does not actively expose a write mutation structurally to alter or destroy existing community integrity ratings.